Sang tao4

Thi HSG Quốc gia 2010
CCKLK: Dãy con chung không liền kề dài nhất
Cho dãy số nguyên dương x = (x1, x2, ..., xn). Dãy y = (xi1, xi2, ..., xik) được gọi là dãy con không liền kề của
dãy x nếu 1  i1 < i21 < ... < ik1  n. Cho 2 dãy số nguyên a gồm n phần tử và b gồm m phần tử. Xác
định chiều dài k của dãy con chung không liền kề dài nhất của a và b. 2  m, n  1000, 1 ai, bi  10000.
CCKLK.INP CCKLK.OUT Giải thích
5 6 2 CCKLK.INP: Dòng đầu: n m. Từ dòng thứ hai trở đi: Dãy số a,
1 5 3 8 2 tiếp đến là dãy số b.
2 1 3 4 2 6 CCKLK.OUT: k.

Thuật toán
Quy hoạch động.
Gọi d(i,j) là đáp số của bài toán khi xét hai dãy a[1..i] và b[1..j]. Ta có:
 Nếu i ≤ 0 thì ta quy ước d(i,j) = 0,
 Nếu a[i] = b[j] thì d(i,j) = d(i−2,j−2),
 Nếu a[i] ≠ b[j] thì d(i,j) = max { d(i−1,j), d(i,j−1) }.
Để cài đặt ta dùng 3 mảng một chiều x, y và z với ý nghĩa x[j] = d(i−2,j), y[j] = d(i−1,j) và z[j] = d(i,j). Khi
đó hệ thức trên được viết là:
 Nếu i ≤ 0 thì ta quy ước d(i,j) = 0,
 Nếu a[i] = b[j] thì d(i,j) = d(i−2,j−2) ứng với z[j] = x[j−2],
 Nếu a[i] ≠ b[j] thì d(i,j) = max { d(i−1,j), d(i,j−1) } ứng với z[j] = max { y[j], z[j−1] }.
Muốn tránh các phép copy dữ liệu từ y sang x; từ z sang y và từ x sang z ta chỉ cần tráo đổi các con trỏ
mảng.
Độ phức tạp
O(n.m)
Chương trình Pascal
(* CCKLK.PAS
k: chieu dai day con chung khong lien ke dai nhat
cua hai day so nguyen duong a[1..n], b[1..m]
*)
const fn = 'ccklk.inp'; gn = 'ccklk.out';
bl = #32; nl = #13#10; mn = 1001;
type int = integer;
mi1 = array[0..mn] of int;
var
n, m: int;
a, b: mi1;

function Max(a,b: int): int;
begin if a >= b then Max := a else Max := b; end;

procedure Doc;
var i: int;
f: text;
begin
assign(f,fn); reset(f);
read(f,n, m);

writeln(n,bl,m);
for i := 1 to n do read(f,a[i]);
for i := 1 to m do read(f,b[i]);
write(nl, 'a: ');
for i := 1 to n do write(a[i],bl);
write(nl, 'b: ');
for i := 1 to n do write(b[i],bl);
close(f);
end;

procedure Ghi(k: int);
var g: text;
begin
assign(g,gn); rewrite(g);
writeln(g,k); close(g);
end;

(*
d(i,j) = dap so cua bai toan voi a[1..i], b[1..j]
d(i,j) = d(i-2,j-2) + 1, if a[i] = b[j]
= Max begin d(i,j-1), d(i-1,j) end;, elsewhere
= 0, if i < 1 || j < 1
*)

function QHD: int;
var i, j, v: int;
c: array[1..3] of mi1;
x, y, z, t: int;
begin
x := 1; y := 2; z := 3;
{ Init i = 0 }
fillchar(c[x],sizeof(c[x]), 0);
{ Init i = 1 }
c[y][0] := 0; v := 0;
for j := 1 to m do
begin
if (a[1] = b[j]) then v := 1;
c[y][j] := v;
end;
v := 0;
for i := 2 to n do
begin
c[z][0] := 0;
if (a[i] = b[1]) then v := 1;
c[z][1] := v;
for j := 2 to m do
if (a[i] = b[j]) then c[z][j] := c[x][j-2]+1
else c[z][j] := Max(c[z][j-1],c[y][j]);
t := x; x := y; y := z; z := t;
end;
QHD := c[y][m];
end;

BEGIN
Doc;
Ghi(QHD);
write(nl,' Fini ');

readln;
END.
Chương trình CPP
/* DevC++ CCKLK.CPP
k: chieu dai day con chung khong lien ke dai nhat
cua hai day so nguyen duong a[1..n], b[1..m]
*/
#include <fstream>
#include <iostream>
using namespace std;
// D A T A A N D V A R I A B L E
const char * fn = "ccklk.inp";
const char * gn = "ccklk.out";
const int mn = 1001;
int n, m;
int a[mn],b[mn];
// P R O T O T Y P E S
void Doc();
int QHD(); // Quy hoach dong
void Ghi(int);
int Max(int,int);

// I M P L E M E N T A T I O N
int main() {
Doc();
Ghi(QHD());
cout << endl << " Fini ";
cin.get();
return 0;
}

int Max(int a, int b) { return (a >= b) ? a : b; }

void Doc() {
int i;
ifstream f(fn);
f >> n >> m;
cout << endl << n << " " << m;
for (i = 1; i <= n; ++i) f >> a[i];
for (i = 1; i <= m; ++i) f >> b[i];
cout << endl << "a: ";
for (i = 1; i <= n; ++i) cout << a[i] << " ";
cout << endl << "b: ";
for (i = 1; i <= m; ++i) cout << b[i] << " ";
f.close();
}

void Ghi(int k) {
ofstream g(gn);
g << k;
g.close();
}
/*
d(i,j) = dap so cua bai toan voi a[1..i], b[1..j]
d(i,j) = d(i-2,j-2) + 1, if a[i] = b[j]
= Max { d(i,j-1), d(i-1,j) }, elsewhere

= 0, if i < 1 || j < 1
*/

int QHD() {
int *x, *y, *z, *t;
int i, j , m1 = m+1, v ;
x = new int[m1];
y = new int[m1];
z = new int[m1];
// Init i = 0
memset(x,0,sizeof(int)*m1);
// Init i = 1
y[0] = 0; v = 0;
for (j = 1; j <= m; ++j) {
if (a[1] == b[j]) v = 1;
y[j] = v;
}
v = 0;
for (i = 2; i <= n; ++i) {
z[0] = 0;
if (a[i]==b[1]) v = 1;
z[1] = v;
for (j = 2; j <= m; ++j)
z[j] = (a[i] == b[j]) ? x[j-2]+1 : Max(z[j-1],y[j]);
t = x; x = y; y = z; z = t;
}
v = y[m];
delete x; delete y; delete z;
return v;
}

Ổn định
Cho đồ thị có hướng gồm n đỉnh và m cung (u,v). Cho trước đỉnh s. Một đỉnh d ≠ s được gọi là ổn định đối
với s nếu có ít nhất hai đường đi ngắn nhất từ s tới d. Hãy tính k là số lượng đỉnh ổn định đối với đỉnh s.
2  n  10000, 1  m  50000.

ONDINH.INP ONDINH.OUT Giải thích
6 7 1 2 ONDINH.INP: Dòng đầu: n m s. Từ dòng thứ hai trở đi:m cung
1 2 dạng u v. Có thể có các cung trùng nhau (dư thừa).
1 4 ONDINH.OUT: k.
2 3 Thí dụ cho biết: có 3 đỉnh ổn định đối với đỉnh 1 là các đỉnh 5
2 5 và 6.
4 5 1 → 2 → 5; 1 → 4→ 5;
2 3 1 → 2 → 5→ 6; 1 → 4→ 5→ 6.
5 6

Thuật toán
Dùng một biến thể của thuật toán Dijkstra.

// Ondinh.CPP
// HSG 2010

#include <string.h>

#include <fstream>
#include <iostream>
//#include <mem.h>


// D A T A A N D V A R I A B L E S

char * fn = "ondinh.inp";
char * gn = "ondinh.out";
const int mm = 50001;
typedef struct { int a, b; } cung;
cung c[mm];
int len[mn]; // len[i] chieu dai s => i
char mark[mn]; // mark[i] danh dau dinh i:
// Chua xet 0; Co trong hang doi q 1; Da xu li 2
int d[mn]; // d[i] so luong duong ngan nhat s => i
int q[mn]; // hang doi
int n, m, s ; // so dinh n, so cung m, dinh xuat phat s
int main();
void Doc();
int XuLi();
int Min(int, int);
int BinSearch(cung [], int, int, int);
int Sanh(int,int,int,int);
void Ghi();

int main(){
Doc(); XuLi(); Ghi();
cout << endl << " Fini"; cin.get();
return 0;
}

int Min(int a, int b) { return (a <= b) ? a : b; }

void Ghi() {
int i, k = 0;
for (i = 1; i <= n; ++i)
if (d[i] > 1) ++k;
ofstream g(gn);
g << k;
g.close();
}

int XuLi() {
int i, j, k, v, r;
v = 0; r = 0;
memset(mark,0,sizeof(mark));
memset(d,0,sizeof(d));
len[s] = 0; d[s] = 1;
q[++v] = s;
while (r < v) { // 1
i = q[++r]; cout << endl << " Xet dinh " << i;
mark[i] = 2;
for (k = BinSearch(c,m,i,0); c[k].a == i; ++k) { // 2

j = c[k].b; // xet cac dinh j ke dinh i
if (mark[j] == 0) {
len[j] = len[i]+1; mark[j] = 1;
d[j] = d[i]; q[++v] = j;
}
else if (mark[j] == 1) {
if (len[i]+1 == len[j]) d[j]++;
}
} // 2
} // 1
for (i = 1; i <= n; ++i) cout << d[i] << " ";
}

int Sanh(int u1, int v1, int u2, int v2) {
if (u1 < u2) return -1;
if (u1 > u2) return 1;
// u1 == u2
if (v1 < v2) return -1;
if (v1 > v2) return 1;
return 0;
}

int BinSearch(cung c[], int k, int u, int v) {
int d = 1, m;
while (d < k) {
m = (d + k) / 2;
if (Sanh(c[m].a,c[m].b,u,v) < 0) d = m+1; else k = m;
}
return d;
}
void Doc() {
int i, j, u, v, k = 0;
ifstream f(fn);
f >> n >> m >> s;
cout << endl << n << " " << m << " " << s;
// The first edge (u,v)
f >> u >> v;
++k; c[k].a = u; c[k].b = v;
for (i = 2; i <= m; ++i) {
f >> u >> v;
j = BinSearch(c,k,u,v);
if (Sanh(c[j].a,c[j].b,u,v) != 0) {
if (Sanh(c[j].a,c[j].b,u,v) < 0) { ++k; c[k].a = u; c[k].b
= v; }
else {
memmove(&c[j+1], &c[j], (k-j+1)*sizeof(cung));// <mem.h>
c[j].a = u; c[j].b = v; ++k;
}
}
}
f.close();
m = k;
}

// Ondinh.CPP Phuong an cu
// HSG 2010

#include <string.h>
#include <fstream>
#include <iostream>
//#include <mem.h>



char * fn = "ondinh.inp";
char * gn = "ondinh.out";
const int mm = 50001;
typedef struct { int a, b; } cung;
cung c[mm];
int p[mn];
char d[mn];
int s[mn];
int n, m, x; // so dinh n, so cung m, dinh xuat phat x
int main();
void Doc();
int XuLi();
int Minp();
int Min(int, int);
int BinSearch(cung [], int, int, int);
int Sanh(int,int,int,int);
void Ghi();

int main(){
Doc(); XuLi(); Ghi();
return 0;
}


int Minp() {
int i, imin = 0;
for (i = 1; i <= n; ++i)
if (!d[i] && p[i] < p[imin]) imin = i;
d[imin] = 1;
return imin;
}

void Ghi() {
int i, k = 0;
for (i = 1; i <= n; ++i)
if (s[i] > 1) ++k;
ofstream g(gn);
g << k;
g.close();
}

int XuLi() {
int i, imin, j, k;
memset(d,0,sizeof(d));
for (i = 2; i <= n; ++i) s[i] = 0;
s[x] = 1;
p[0] = n+2; p[x] = 0;
for (i = 2; i <= n; ++i) p[i] = n+1;
for (i = 1; i <= n; ++i) {
imin = Minp();
for (k = BinSearch(c,m,imin,0); c[k].a == imin; ++k) {
j = c[k].b;
if (!d[j]) {
if (p[imin]+1 < p[j]) { p[j] = p[imin]+1; s[j] =
s[imin]; }
else if (p[imin]+1 == p[j]) ++s[j];
}
}
}
}

int Sanh(int u1, int v1, int u2, int v2) {
if (u1 < u2) return -1;
if (u1 > u2) return 1;
// u1 == u2
if (v1 < v2) return -1;
if (v1 > v2) return 1;
return 0;
}

int BinSearch(cung c[], int k, int u, int v) {
int d = 1, m;
while (d < k) {
m = (d + k) / 2;
if (Sanh(c[m].a,c[m].b,u,v) < 0) d = m+1; else k = m;
}
return d;
}
void Doc() {
int i, j, u, v, k = 0;
ifstream f(fn);
f >> n >> m >> x;
// The first edge (u,v)
f >> u >> v;
++k; c[k].a = u; c[k].b = v;
for (i = 2; i <= m; ++i) {
f >> u >> v;
j = BinSearch(c,k,u,v);
if (Sanh(c[j].a,c[j].b,u,v) != 0) {
if (Sanh(c[j].a,c[j].b,u,v) < 0) { ++k; c[k].a = u; c[k].b
= v; }
else {
memmove(&c[j+1], &c[j], (k-j+1)*sizeof(cung));// <mem.h>
c[j].a = u; c[j].b = v; ++k;
}
}
}
f.close();

m = k;
}

Mã số thuế
Xét tập S gồm tất cả các số 1..n trong hệ 36, 36  n  1016. Cho số m: 3  m  70. Xét dãy số nguyên 1 < c1
< c2 < ... < ck < 36, k = (m1)/2 , x là số nguyên lớn nhất không vượt quá x.
Chọn các số chứa các chữ số < c1 cấp cho 2 nhóm 1 và 2 rồi xóa các số này. Chọn các số chứa các chữ số
< c2 cấp cho 2 nhóm 3, 4.... Các số còn lại cấp cho 1 hoặc 2 nhóm cuối.
Nhóm le: từ nhỏ, nhóm chẵn: từ lớn.
Cho các số hệ 10: n, m, ci, p và q. Xác định mã (hệ 36) cấp cho ng thứ q nhóm p.
Thí dụ:
n = 50, m = 3, p = 2, q = 2, c1 = 16. 1d
Căt đoạn
Cho hình chữ nhật OABC, OA = n, OC = m, coi O là gốc tọa độ (0,0). Trong hình CN cho k đoạn thẳng
đứng. Tìm điểm P trên BA hoặc BC để đoạn OP cắt nhiều đoạn nhất.

Đoạn khác nhau
Cho dãy a gồm n số nguyên dương. Một đoạn của dãy a, kí hiệu a[i..j] là dãy gồm các phần tử đứng liên
tiếp nhau trong dãy a, kể từ phần tử ai đến phần tử aj, a[i..j] = (ai, ai+1,...,aj-1, aj), 1  i <= j  n. Hãy tìm
đoạn dài nhất gồm các phần tử đôi một khác nhau.
1  n, ai  100000.
Dữ liệu vào: Tệp văn bản diff.inp
 Dòng đầu tiên: số n.
 Từ dòng thứ hai trở đi: dãy số a.
Dữ liệu ra: Tệp văn bản diff.out chứa 2 số:
 imax  chỉ số đầu tiên của đoạn dài nhất tìm được trong dãy a
 dmax  số phần tử của doạn dài nhất.
Các số trên cùng dòng cách nhau qua dấu cách.

diff.inp diff.out Giải thích
Tính từ phần tử thứ 3 có cả thảy
10 3
8 số đôi một khác nhau là
5 2 4 1 5 8
3 2 7 6 9 4 1 5 3 2 7 6 9

Thuật toán
Lần lượt đọc các phần tử ai của dãy a và đánh dấu vị trí xuất hiện của ai trong dãy thông qua mảng p, p[ai] =
i. Với thí dụ đã cho, sau khi đọc và xử lý xong dãy a ta phải thu được

i 1 2 3 4 5 6 7 8 9 10
ai 5 2 4 1 5 3 2 7 6 9
p 4 2/7 6 3 1/5 9 8 0 10 0

p[2] = 2/7 cho biết số 2 lúc đầu xuất hiện tại vị trí 2 trong dãy a, sau đó
xuất hiện tại vị trí 7 trong dãy a. p[8] = p[10] = 0 cho biết các số 8 và 10
không xuất hiện trong dãy a.

Ta gọi p là dãy trỏ ngược hay dãy vị trí của dãy a. Ta xử lý từng đoạn d của ai như sau. Mỗi đoạn d sẽ bao
gồm một dãy liên tiếp các phần tử đôi một khác nhau tính từ chỉ số i đến j. Thí dụ trên cho ta lần lượt 3
đoạn sau:
 Đoạn thứ nhất d = a[1..4] = (5, 2, 4, 1), i = 1, j = 4,
 Đoạn thứ hai d = a[2..6] = (2, 4, 1, 5, 3), i = 2, j = 6,
 Đoạn thứ ba d = a[3..10] = (4, 1, 5, 3, 2, 7, 6, 9), i = 3, j = 10.
Mỗi đoạn d được xác định như sau: Mỗi khi gặp phần tử aj đầu tiên trùng với một phần tử trong dãy tính từ
i thì ta cắt ra được đoạn d = a[i..j1].
Với mỗi đoạn d[i..j] ta tính số phần tử của đoạn đó là ji+1 và cập nhật giá trị dmax. Để khởi trị cho đoạn
tiếp theo, ta đặt i = p[aj]+1. Chú ý rằng p[aj] là vị trí xuất hiện của giá trị lặp aj.
Độ phức tạp
O(n)
(* diff.pas
Tim doan dai nhat gom cac
phan tu doi mot khac nhau
*)

const fn = 'diff.inp'; gn = 'diff.out';
bl = #32; nl = #13#10;
mn = 100001;
var p: array[0..mn] of longint;
n: longint;
imax, dmax: longint;
{ imax - chi so dau tien cua doan dai nhat
dmax - so phan tu cua doan dai nhat }
f,g: text;

procedure Run;
var i, j, v, istart: longint;
begin
imax := 0; dmax := 0;
fillchar(p,sizeof(p),0);
readln(f,n);
read(f,v); { phan tu dau tien trong day }
p[v] := 1; istart := 1;
for i := 2 to n do
begin
read(f,v);
if (p[v] >= istart) then
begin
if (i-istart > dmax)then
begin
dmax := i-istart; imax := istart;
end;
istart := p[v]+1;

end;
p[v] := i;
end;
close(f);
i := n+1;
if (i-istart > dmax) then
begin
dmax := i-istart; imax := istart;
end;
write(g, imax, nl, dmax);
close(g);
end;

BEGIN
Run;
write(nl, ' Fini '); readln;
END.
Chương trình CPP
/* DevC++: Diff.cpp
phan tu doi mot khac nhau
*/

#include <fstream>
#include <iostream>



const char * fn = "diff.inp";
const char * gn = "diff.out";
int p[mn]; // p[v] = i: noi xuat hien so v trong day
int n;
int imax; // chi so dau tien cua doan dai nhat
int dmax; // so phan tu cua doan dai nhat


int main();
void Run();


int main() {
Run();
cout << endl;
system("PAUSE");
return EXIT_SUCCESS;
}

void Run() {
int i, j, v, istart;
imax = 0, dmax = 0;

memset(p,0,sizeof(p));
ifstream f(fn);
f >> n;
f >> v; // v phan tu dau day
p[v] = 1; istart = 1;
for (i = 2; i <= n; ++i) {
f >> v;
if (p[v] >= istart) { // so v co trong doan istart..i
if (i-istart > dmax) {
dmax = i-istart; imax = istart;
}
istart = p[v]+1;
}
p[v] = i;
}
f.close();
i = n+1;
if (i-istart > dmax) {
dmax = i-istart; imax = istart;
}
ofstream g(gn); g << imax << endl << dmax;
}

Hoán vị 1k
Cho dãy a gồm n số nguyên dương đôi một khác nhau. Hãy tìm đoạn dài nhất gồm các phần tử tạo thành
một hoán vị của dãy (1, 2 ,..., k), 1  n, ai  100000.
Dữ liệu vào: Tệp văn bản hv1k.inp
Dữ liệu ra: Tệp văn bản hv1k.out chứa 2 số:
 dmax  số phần tử của đoạn dài nhất.

hv1k.inp hv1k.out Giải thích
10 3 Tính từ phần tử thứ 3 có 6 số
5 2 4 1 5 6 liên tiếp tạo thành một hoán vị
3 2 6 9 8 của 1..6 là
4 1 5 3 2 6

Thuật toán
Kí hiệu a[i..j] là đoạn gồm các phần tử liên tiếp từ ai đến aj của dãy a và kí hiệu set(x) là tập chứa các phần
tử (khác nhau) của dãy x. Với thí dụ đã cho ta có, a[1..5] = (5, 2, 4, 1, 5) và do đó set(a[1..5]) = {1, 2, 4,
5}. Gọi p là dãy vị trí (trỏ ngược) của dãy a. Vì dãy a gồm các phần tử đôi một khác nhau nên p cũng chứa
các chỉ số đôi một khác nhau. Khi đó a chứa một đoạn là hoán vị của k số tự nhiên đầu tiên (1,2,...,k) khi và
chỉ khi tìm được hai chỉ số s và e thỏa đồng thời hai tính chất sau:
 es+1 = k, và
 set(a[s..e]) = {1, 2, ... , k}.

Trong thí dụ trên ta tìm được s = 3, e = 8, k = 6, a[3..8] = (4, 1, 5, 3, 2, 6), và do đó set(a[3..8]) = {1, 2, 3, 4,
5, 6}.
Xét dãy chỉ số 1, 2, ..., i thỏa tính chất  j: 1  j  i: p[j] ≠ 0.
Để ý rằng điều kiện p[j] ≠ 0 tương đương với điều kiện giá trị j của dãy a xuất hiện tại vị trí p[j]. Đặt s =
min p[1..i] = min {p[1], p[2], ... , p[i]} và e = max p[1..i] = max {p[1], p[2], ... , p[i]}. Ta thấy a chứa một
đoạn là hoán vị của dãy (1,2,...,i) khi và chỉ khi es+1 = i.
Độ phức tạp
O(n).
(* --------------------------------------
hv1k.pas
Tim doan dai nhat trong day so
doi mot khac nhau tao thanh mot
hoan vi 1..k
-----------------------------------------*)

const fn = 'hv1k.inp'; gn = 'hv1k.out';
mn = 1000002; nl = #13#10; bl = #32;
n: longint;
f,g: text;

procedure Doc;
var i, v: longint;
begin
readln(f,n);
for i := 1 to n do
begin
read(f,v); p[v] := i;
end;
close(f);
end;

function Min(a,b: longint): longint;
begin
if (a <= b) then Min := a else Min := b
end;

function Max(a,b: longint): longint;
begin
if (a >= b) then Max := a else Max := b
end;

procedure Hv;
var i, pmin, pmax: longint;
begin
pmin := n+1; pmax := 0;
imax := 0; dmax := 0;
for i := 1 to n do
begin
if (p[i] = 0) then break;

pmin := Min(pmin,p[i]);
pmax := Max(pmax,p[i]);
if (pmax - pmin + 1 = i) then
begin
imax := pmin;
dmax := pmax - pmin + 1;
end;
end;
end;

procedure Ghi;
begin
writeln(g, imax,nl,dmax);
close(g);
end;

procedure Run;
begin
Doc; Hv; Ghi;
end;

BEGIN
Run;
write(nl,' Fini '); readln;
END.

Chương trình CPP
/* --------------------------------------
devCPP: hv1k.cpp
hoan vi 1..k
-----------------------------------------*/
#include <fstream>
#include <iostream>



const char * fn = "hv1k.inp";
const char * gn = "hv1k.out";
int p[mn];
int n;
int imax, dmax;


int main();
void Doc();
int Min(int, int);
int Max(int, int);
void Hv();
void Ghi();

void Run();


int main() {
Run();
cout << endl;
system("PAUSE");
}

void Doc() {
int i, v;
ifstream f(fn);
f >> n;
for (i = 1; i <= n; ++i) {
f >> v;
p[v] = i;
}
f.close();
}



void Hv() {
int i, pmin = n+1, pmax = 0;
imax = 0; dmax = 0;
for (i = 1; i <= n; ++i) {
if (p[i] == 0) break;
pmin = Min(pmin,p[i]);
pmax = Max(pmax,p[i]);
if (pmax - pmin + 1 == i) {
imax = pmin;
dmax = pmax - pmin + 1;
}
}
}
void Ghi() {
ofstream g(gn);
g << imax << endl << dmax;
g.close();
}

void Run() {
Doc();
Hv();
Ghi();
}

Hoán vị sk
Cho dãy a gồm n số nguyên dương đôi một khác nhau. Hãy tìm đoạn dài nhất gồm các phần tử tạo thành
một hoán vị của dãy số tự nhiên liên tiếp (s, s+1 ,..., k), 1  n, ai  100000.

Dữ liệu vào: Tệp văn bản hvsk.inp
Dữ liệu ra: Tệp văn bản hvsk.out chứa 2 số:

hvsk.inp hvsk.out Giải thích
7 3 Tính từ phần tử thứ 3 trong dãy
12 1 4 7 8 5 a có 5 số liên tiếp tạo thành một
5 6 hoán vị của 4..8 là a[3..7]:
4 7 8 5 6

Thuật toán
Gọi p là dãy trỏ ngược của dãy a. Vì dãy a gồm các phần tử đôi một khác nhau nên p cũng chứa các chỉ số
đôi một khác nhau. Khi đó a chứa một đoạn là hoán vị của dãy số tự nhiên liên tiếp s..k khi và chỉ khi tìm
được hai chỉ số i và j thỏa đồng thời hai tính chất sau:
 ji = ks, và
 set(a[i..j]) = {s, s+1, ... , k}.
Trong thí dụ trên ta tìm được i = 3, j = 7, s = 4, k = 8, a[3..7] = (4, 7, 8, 5, 6), và do đó set(a[3..7]) = {4, 5,
6, 7, 8}.
Khi đọc dữ liệu ta đồng thời xác định hai giá trị cận vmin và vmax của dãy a. Để ý rằng p[vmin..vmax]
gồm các đoạn toàn 0 và đoạn khác 0 đan xen nhau. Thí dụ trên cho ta

ai 1 2 3 4 5 6 7 8 9 10 11 12
p 2 0 0 3 6 7 4 5 0 0 0 1
vmin = 1. vmax = 12

Khi duyệt p[vmin..vmax] ta xét 2 trạng thái 0 và 1 như sau:
Trạng thái 0: Duyệt đoạn p toàn 0, p[2..3] và p[9..11].
Nếu gặp p[i] > 0 thì khởi trị cho trạng thái duyệt đoạn khác 0, p[istart..]:
 Ghi nhận chỉ số đầu đoạn khác 0: istart = i,
 Khởi trị cac giá trị pmin = min p[istart..k1] và pmax = max p[istart..k1] cho đoạn này: pmin =
pmax = p[i],
 Chuyển qua trạng thái 1.
Trạng thái 1: Duyệt đoạn p khác 0, p[1..1], p[4..8] và p[12..12].
Nếu p[i] > 0 thì cập nhật các chỉ số pmin và pmax. Kiểm tra đẳng thức pmaxpmin = iistart để cập nhật
chỉ số đầu tiên của đoạn hoán vị trong dãy a, imax và chiều dài của đoạn hoán vị, dmax.
Nếu p[i] = 0 thì kết thúc việc duyệt đoạn p[isstart..i1] này, chuyển qua trạng thái 0.
Độ phức tạp
O(n).


Chương trình CPP
/* --------------------------------------
hvsk.cpp
hoan vi cua day so tu nhien lien tiep
s, s+1,...,k
-----------------------------------------*/
#include <fstream>
#include <iostream>



const char * fn = "hvsk.inp";
const char * gn = "hvsk.out";
int p[mn];
int pmin, pmax;
int vmin, vmax;
int n;
int imax, dmax;


int main();
void Doc();
int Min(int, int);
int Max(int, int);
void Hv(); // Sliding window
void Ghi();
void Run();


int main() {
Run();
cout << endl;
system("PAUSE");
}

void Doc() {
int i, v;
ifstream f(fn);
vmin = mn; vmax = 0;
f >> n;
for (i = 1; i <= n; ++i) {
f >> v;
p[v] = i;
vmin = Min(vmin,v); vmax = Max(vmax,v);

}
f.close();
}



void Hv() {
int i, istart, q = 0; // trang thai q
dmax = 0; ++vmax;
for (i = vmin; i <= vmax; ++i) {
switch(q) {
case 0: // duyet doan toan 0
if (p[i] > 0) { // Khoi tri khi gap so khac 0
pmin = pmax = p[i];
istart = i; q = 1;
}
break;
case 1: // duyet doan khac 0
if (p[i] > 0) {
if (pmax-pmin == i-istart && pmax-pmin+1 > dmax){
dmax = pmax-pmin+1;
imax = pmin;
}
}
else q = 0;
break;
} // end switch
} // end for
}

void Ghi() {
ofstream g(gn);
g.close();
}

void Run() {
Doc();
Hv();
Ghi();
}

Hoán vị 1k dài nhất

IOIcamp Marathon 2005-2006

Cho dãy a gồm n số nguyên dương. Hãy tìm đoạn dài nhất gồm các phần tử tạo thành một hoán vị của dãy
số tự nhiên 1..k; 1  n, ai  100000.
Dữ liệu vào: Tệp văn bản hv1kmax.inp

Dữ liệu ra: Tệp văn bản hv1kmax.out chứa 2 số:

hv1kmax.inp hv1kmax.out Giải thích
3 2 3 1 2 hoán vị của 1..5 là a[3..7]:
4 1 5 3 2

Thuật toán
Duyệt dãy, dựa theo bài diff, xác định từng đoạn ứng viên a[d..c] chứa tối đa các phần tử liên tiếp nhau
trong dãy a và đôi một khác nhau. Với mỗi đoạn ứng viên, dựa theo bài Hv1k, gọi thủ tục Hv(d,c) xác định
và cập nhật đoạn dài nhất trong a[d..c] tạo thành một hoán vị của dãy số tự nhiên 1..k.
Độ phức tạp
(* hv1kmax.pas: Tim doan dai nhat gom cac
phan tu tao thanh mot hoan vi cua 1..k *)

const fn = 'hv1kmax.inp'; gn = 'hv1kmax.out';
mn = 100002; bl = #32; nl = #13#10;

{ p[v] - noi xuat hien gia tri v trong day }
n: longint;
f, g: text;

function Min(a,b: longint): longint;
begin if (a <= b) then Min := a else Min := b; end;

function Max(a,b: longint): longint;
begin if (a >= b) then Max := a else Max := b; end;

procedure Hv(d,c: longint);
var i, pmin, pmax: longint;
begin
pmin := c+1; pmax := d-1;
for i := 1 to c-d+1 do
begin
if (p[i] < d ) or (p[i] > c) then break;
pmin := Min(pmin,p[i]);
pmax := Max(pmax,p[i]);
if (i > dmax) then
begin
if (pmax - pmin + 1 = i) then

begin
imax := pmin;
dmax := i;
end
end
end;
end;

procedure Ghi;
begin
writeln(g,imax, nl, dmax); close(g);
end;

procedure Run;
var i, v , istart: longint;
begin
imax := 0; dmax := 0;
readln(f,n);
read(f,v); { v – phan tu dau day a }
p[v] := 1; istart := 1; { chi so dau doan }
for i := 2 to n do
begin
read(f,v);
if (p[v] >= istart) then { gap phan tu trung lap }
begin
if (i-istart > dmax) then Hv(istart, i-1);
istart := p[v]+1; { Khoi tri dau doan moi }
end;
p[v] := i;
end;
close(f);
if (n+1-istart > dmax) then Hv(istart,n);
Ghi;
end;

BEGIN
Run;
write(nl,' Fini '); readln;
END.

Chương trình CPP

/* DevC++: hv1kmax.cpp
phan tu tao thanh mot hoan vi cua 1..k
*/
#include <fstream>
#include <iostream>



const char * fn = "hv1kmax.inp";
const char * gn = "hv1kmax.out";
int p[mn]; // p[v] - noi xuat hien gia tri v trong day
int n;
int imax, dmax;


int main();
void Run();
int Min(int, int);
int Max(int, int);
void Hv(int, int); // Sliding window
void Ghi();


int main() {
Run();
cout << endl;
system("PAUSE");
}



// tim hoan vi 1..n trong doan
// gom cac phan tu khac nhau doi mot
void Hv(int d, int c) {
int i, pmin = c+1, pmax = d-1;
int n = c-d+1;
for (i = 1; i <= n; ++i) {
if (p[i] < d || p[i] > c) break;
if (i > dmax) {
if (pmax - pmin + 1 == i) {
imax = pmin;
dmax = i;
}
}
}
}

void Ghi() {
ofstream g(gn);
g.close();
}

void Run() {
int i, v , istart;
imax = 0; dmax = 0;

ifstream f(fn);
f >> n;
f >> v; p[v] = 1; istart = 1;
for (i = 2; i <= n; ++i) {
f >> v;
if (p[v] >= istart) {
if (i-istart > dmax) Hv(istart, i-1);
istart = p[v]+1;
}
p[v] = i;
}
f.close();
if (n+1-istart > dmax) Hv(istart,n);
Ghi();
}

Hoán vị sk dài nhất
Cho dãy a gồm n số nguyên dương. Hãy tìm đoạn dài nhất gồm các phần tử tạo thành một hoán vị của dãy
số nguyên dương liên tiếp s, s+1,...,k; 1  n, ai  100000.
Dữ liệu vào: Tệp văn bản hvskmax.inp
Dữ liệu ra: Tệp văn bản hvskmax.out chứa 2 số:

hvskmax.inp hvskmax.out Giải thích
8 6 3 9 2 hoán vị của 5..9 là a[3..7]:
9 7 5 8 6

Thuật toán
Pha 1. Đọc dãy a, với mỗi ai ghi nhận p[ai] = i là vị trí xuât hiện giá trị ai. Gọi vmin và vmax lần lượt là giá
trị min và max của dãy a.
Pha 2. Duỵệt dãy giá trị i = vmin..vmax tạo thành một đoạn d gồm các giá trị xuất hiện liên tiếp trong dãy
a, xác định các giá trị pmin và pmax là vị trí xuất hiện đầu tiên và cuối cùng trong đoạn d. Đoạn d là một
hoán vị của dãy số nguyên dương liên tiếp i, i+1,...,s khi và chỉ khi pmaxpmin+1 = si.
Độ phức tạp
Chương trình CPP

/* DevC++: hv1kmax.cpp
phan tu tao thanh mot hoan vi cua s..k
*/

#include <fstream>
#include <iostream>



const char * fn = "hvskmax.inp";
const char * gn = "hvskmax.out";
int p[mn]; // p[v] - noi xuat hien gia tri v trong day
int a[mn];
int n;
int imax, dmax;


int main();
void Run();
int Min(int, int);
int Max(int, int);
void Hv(int, int); // Sliding window
void Ghi();


int main() {
Run();
cout << endl;
system("PAUSE");
}



void Hv(int d, int c) {
int i, istart, q = 0, pmin = c+1, pmax = d-1;
int vmin, vmax;
// trang thai q
vmin = vmax = a[d];
for (i = d+1; i <= c; ++i) {
vmin = min(vmin,a[i]);
vmax = max(vmax,a[i]);
}
for (i = vmin; i <= vmax; ++i) {
switch(q) {
case 0: // duyet doan toan 0
if (p[i] > 0) { // Khoi tri khi gap so khac 0
pmin = pmax = p[i];
istart = i; q = 1;
}
break;
case 1: // duyet doan khac 0
if (p[i] > 0) {

if (pmax-pmin == i-istart && pmax-pmin+1 > dmax){
dmax = pmax-pmin+1;
imax = pmin;
}
}
else q = 0;
break;
} // end switch
} // end for
}

void Ghi() {
ofstream g(gn);
g.close();
}

void Run() {
int i, v , istart;
imax = 0; dmax = 0;
ifstream f(fn);
f >> n;
f >> v; a[1] = v; p[v] = 1; istart = 1;
for (i = 2; i <= n; ++i) {
f >> v; a[i] = v;
if (p[v] >= istart) {
if (i-istart > dmax) Hv(istart, i-1);
istart = p[v]+1;
}
p[v] = i;
}
f.close();
if (n+1-istart > dmax) Hv(istart,n);
Ghi();
}

Đoạn nguyên tố
Cho n số tự nhiên ai i = 1..n. Hãy tìm đoạn dài nhất gồm các phần tử là các số nguyên tố.
1  n, ai  100000.
/* ---------------------------------------
Primes.cpp
Tim doan dai nhat gom cac so nguyen to
----------------------------------------*/
#include <fstream>
#include <iostream>
#include <math.h>



const char * fn = "primes.inp";

char p[mn]; // p[i] = 0=> i nguyen to
int n;
int imax, dmax;

void Run();
void Sang(int);
void Duyet();

int main() {
Run();
cin.get();
return 0;
}

void Sang(int n) {
int can = (int) sqrt(n);
int i, j, k;
p[0] = p[1] = 1;
for (i = 2; i <= can; ++i)
if (p[i]==0)
for (k = n/i, j = i; j <= k; ++j) p[i*j] = 1;
}

void Duyet() {
int i, x, d;
imax = 0; dmax = 0; d = 0;
ifstream f(fn);
f >> n;
for (i = 1; i <= n; ++i) {
f >> x; cout << x << " ";
if (p[x]) { // x khong nguyen to
if (d > dmax) {
dmax = d; imax = i;
}
d = 0;
} else ++d;
}
f.close();
if (d > dmax) {
dmax = d; imax = n+1;
}
imax = imax - dmax;
}

void Run() {
Sang(mn);
Duyet();
cout << endl << imax << " " << dmax;
}

Đoạn nguyên tố cùng nhau

Cho n số tự nhiên ai i = 1..n. Hãy tìm đoạn dài nhất gồm các phần tử, trong đó hai phần tử kề nhau thì
nguyên tố cùng nhau.
1  n, ai  100000.

/* ---------------------------------------
Primes.cpp
Tim doan dai nhat gom cac so nguyen to
cung nhau
----------------------------------------*/
#include <fstream>
#include <iostream>
#include <math.h>



const char * fn = "coprime.inp";
char p[mn]; // p[i] = 0=> i nguyen to
int n;
int imax, dmax;

void Run();
void Duyet();
int Gcd(int, int);

int main() {
Run();
cin.get();
return 0;
}

int Gcd(int a, int b) {
int r;
while (b) {
r = a % b; a = b; b = r;
}
return a;
}

void Duyet() {
int i, x, y, d; // d dem so cap nguyen to cung nhau
imax = 0; dmax = 0; d = 0;
ifstream f(fn);
f >> n >> x;
for (i = 2; i <= n; ++i) {
f >> y;
if (Gcd(x,y) == 1) ++d;
else {
if (d > dmax) {
dmax = d; imax = i;
}

d = 0;
}
x = y;
}
f.close();
if (d > dmax) {
dmax = d; imax = n;
}
++dmax; imax = imax - dmax;
}

void Run() {
Duyet();
}

Bài toán Euler N 28
Trong ma trận vuông n X n, n lẻ xuất phát từ ô giữa ghi lần lượt các số từ 1..n2 theo đường xoắn ốc theo
chiều kim dồng hồ. Với n = 5 tổng các phần tử trên 2 đường chéo là 101. Hãy tính tổng này với n = 1001.

21 22 23 24 25

20 7 8 9 10

19 6 1 2 11

18 5 4 3 12

17 16 15 14 13

Nhận xét
Xét các số nằm ở bốn góc của hình vuôn cạnh n. Số ở góc trên phải là n2, các số còn lại
lần lượt là n2−(n−1), n2−2(n−1) và n2−3(n−1). Tổng 4 số này là
d(n) = n2 + n2−(n−1) + n2−2(n−1) + n2−3(n−1) = 4n2 − 6(n−1), n > 1
Với n = 1, d(1) = 1.
Tổng các số trên hai đường chéo chính là
s(n) = d(1) + d(3) +…+d(n).

/*
Name: Problem Euler 28

Copyright: NXH 2010
Author: Nguyen Xuan Huy
Date: 10/06/10 10:53
Description:
2 mau (den, trang) va 16 mau
*/

#include <iostream>
#include <stdio.h>


int Euler28(int n) {
int e = 1;
for (int i = 3; i <= n; i += 2)
e += 4*i*i - 6*(i-1);
return e;
}

main() {
cout << endl << Euler28(1001); // 669171001
cout << endl << " Fini";
cin.get();return 0 ;
}

Bài toán Euler N 52
Số x = 125874, và 2x = 251748 được tạo bởi cùng chữ số theo trật tự khác nhau. Tìm số tự nhiên nhỏ nhất
x sao cho 2x, 3x, 4x, 5x và 6x có các chữ số ddoooi một khác nhau và là những hoán vị của x. (142857)
Có trên 5 số thỏa tính chất trên hay ko?
Nếu ko đòi hỏi các chữ số khác nhau?
Với các số nguyên dương 1..4294967295 (232 − 1) có 10 số
1. : 142857
2. : 1428570
3. : 1429857
4. : 14285700
5. : 14298570
6. : 14299857
7. : 142857000
8. : 142985700
9. : 142998570
10. : 142999857

Chương trình tính và ghi file 10 số

/*
Copyright: NXH 2010

Date: 10/06/10 10:53
Description:
*/

#include <iostream>
#include <fstream>

typedef uint32_t UI;

const UI maxint = (UI)0xffffffff;


char digits[10];
char mark[10];

void GetDigits(UI x, char dg[]) {
for (int i = 0; i < 10; ++i) dg[i] = 0;
do {
++dg[x%10];
x /= 10;
} while (x);
}

bool SameDigits(UI x) {
GetDigits(x,mark);
for (int i = 0; i < 10; ++i)
if (digits[i] != mark[i]) return false;
return true;
}

bool Test(UI x) {
GetDigits(x,digits);
UI d = x;
x += d; // 2x
for (int i = 2; i <= 6; ++i, x += d) {
if (!SameDigits(x)) return false;
}
return true;
}

UI Euler52(UI n) {
bool b;
for (UI x = n+1; x <= maxint; ++x)
if (Test(x)) return x;
return 0;
}

int Euler52m() { // co tren 10 so Euler52?
int d;
UI x = 0;
ofstream f("Euler52.txt");

for (d = 0; (x = Euler52(x)) > 0;) {
++d;
f << endl << d << ". : " << x;

// if (d == 10) break;
}
f.close();
return d;
}

main() {

int d = Euler52m();
cout << "nn Found: " << d;
cin.get();return 0 ;
}

Các số nguyên tố

Tìm được 340059 số, số cuối là 4870843 với lặp n < 500.
Ý tưởng: nếu p[1..n] , c = p[n] là danh sách n số nguyên tố đầu tiên và x là một số lẻ trong khoảng c..c*c thì
x là nguyên tố khi và chỉ khi x không có ước nguyên tố trong khoảng 3.. x.
Xuất phát p = (2,3) − 2 số nguyên tố đầu tiên. n = 2 là số lượng các số nguyên tố hiện tìm được.
Find: xét các số lẻ x trong khoảng từ pn + 2 đến pn2 − 2. Chú ý, do pn là số lẻ nên pn2 lẻ. Nếu x là ng tố thì
thêm vào dãy.
Để kiểm tra tính ng tố của x

/*
Copyright: NXH 2010
Date: 10/06/10 10:53
Description:
*/

#include <iostream>
#include <math.h>


const UI maxn = 20000000;


UI p[maxn];
UI n;

bool IsPrime(UI x) {
UI can = (UI) sqrt(x);
for (UI i = 2; p[i] <= can; ++i)
if (x % p[i] == 0) return false;
return true;
}

// Tim tu n
void Find() {
UI n2 = p[n]*p[n] - 2;
for (UI i = p[n] + 2; i <= n2; i += 2)
if (IsPrime(i)) p[++n] = i;
}

void Run() {
p[1] = 2; p[2] = 3;
n = 2;
while (n < 500) {
cout << endl << " Find with n = " << n;
Find();
cout << endl << " Tong cong " << n << " so nguyen to ";
cout << endl << " So nguyen to lon nhat: " << p[n];
cin.get();
}
}

main() {
Run();
cin.get();
return 0 ;
}

Problem Euler 1

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and
9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

/*
Copyright: NXH 2010
Date: 10/06/10 10:53
Description:
If we list all the natural numbers below 10 that are multiples
of 3 or 5,
we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.

*/

#include <iostream>
#include <stdio.h>



inline int Min(int a, int b) { return (a <= b) ? a : b; }

int Euler01(int maxval) {
int a[mn];
int n;
int i3 = 0, i5 = 0;
int s = 0;
n = 0;
a[0] = 1;
while (a[n] < maxval) {
while (3*a[i3] <= a[n]) ++i3;
// 3*a[i3] > a[n]
while (5*a[i5] <= a[n]) ++i5;
// 5*a[i5] > a[n]
a[++n] = Min(3*a[i3],5*a[i5]);
}
if (a[n] > maxval) --n;
for (int i = 1; i <= n; ++i) s += a[i];
return s;
}

main() {

cout << endl << Euler01(1000); // 3822
cin.get();
return 0 ;
}

Each new term in the Fibonacci sequence is generated by adding the previous two terms.
By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

Find the sum of all the even-valued terms in the sequence which do not exceed four
million.

Thuật toán

Ta có f1 = 1; f2 = 2 là số chẵn đầu tiên. Vì tổng lẻ + lẻ = chẵn và lẻ + chẵn = chẵn + lẻ =
lẻ, nên sâu 2 số lẻ ta mới gặp 1 số chẵn. Từ đó suy ra các fi với i = 2 + 3k, k = 0, 1, … là
các số chẵn. của số chẵn. Gọi fi là số chẵn, ta có:

fi−1 là số lẻ sát trước fi.

fi+1 = fi−1 + fi (lẻ),

fi+2 = fi + fi+1 = fi + fi−1 + fi = 2fi + fi−1 (lẻ),

fi+3 = f i+1 + fi+2 = fi−1 + fi + 2fi + fi−1 = 3fi + 2fi−1 = 2fi+2 − fi (chẵn)

Ta sử dụng biến odd để lưu số lẻ và biến even lưu số chẵn sát sau odd. Ta có,

Khởi trị: odd = 1; even = 2;

Bước tiếp theo: odd = 2*even + odd; even = 2*odd – even;

/*
Copyright: NXH 2010
Date: 10/06/10 10:53
Description:
Each new term in the Fibonacci sequence is generated by adding
the previous two terms. By starting with 1 and 2, the first 10
terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

Find the sum of all the even-valued terms in the sequence
which do not exceed four million.

*/

#include <iostream>
#include <stdio.h>


int Euler02(int maxval) {
int odd = 1, even = 2;
int s = even;
while (even < maxval) {
odd = 2*even + odd;
even = 2*odd - even;
s += even;
}
if (even > maxval) s -= even;
return s;
}

main() {
cout << endl << Euler02(4000000); // 4613732
cin.get();
return 0 ;
}

Euler03

The prime factors of 13195 are 5, 7, 13 and 29.
What is the largest prime factor of the number 600851475143 ?

Khởi trị với danh sách chứa k = 2 số nguyên tố p[1] = 2; p[2] = 3. Hàm NextPrime(k) tìm số nguyên tố sát
sau sô nguyên tố p[k]. Gọi hàm NextPrime nhiều lần đến khi thu được số nguyên tố p[k] > n . DuThe
prime factors of 13195 are 5, 7, 13 and 29.
What is the largest prime factor of the number 600851475143 ? (6857)

/*
Name: Euler03
Copyright: NXH 2010
Date: 10/06/10 10:53
Description:
The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number
600851475143 ?
*/

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <time.h>


typedef long double BI; // kieu gia nguyen

BI p[100000];
BI x = 600851475143.0;

// Test if y is a prime number

bool IsPrime(BI y) {
BI ys = floorl(sqrt(y));
for (int i = 1; p[i] <= ys; ++i)
if (fmodl(y,p[i]) == 0.0) return false;
return true;
}

// Given a list consequenced first k prime numbers
// p[1..k] = (3,5,7,..p[k]), k > 1.
// Find the next prime number (after p[k])

inline BI NextPrime(int k) {
BI n;
for (n = p[k] + 2; !IsPrime(n); n += 2);
return n;
}

// Find the lagest prime factor of a given integer n

BI Euler03(BI n) {
BI sn;
int i, imax, k = 2;
BI m;
// Initialize: p[1..2] = (2,3); k = 2: two first
prime numbers (2 and 3).
p[1] = 2; p[2] = 3;
sn = floorl(sqrt(n));
cout << endl << " n = " << n << " sqrt(n) = " <<
sn;
// Find consequenced prime numbers not greater
than sqrt(n)
while (p[k] < sn) {
m = NextPrime(k);
p[++k] = m;
}
cout << endl << " Found " << k << " prime
number(s). " << endl;
cout << endl << " The last one is : " << p[k];
// Find the last index imax in p[1..k] so p[imax]
is a prime factor of n
imax = 0;
for (i = 1; i <= k; ++i)
if (fmodl(n,p[i]) == 0.0) {
imax = i;
do { n /= p[i]; } while (fmodl(n,p[i]) ==
0.0);
}
cout << "n Now n = " << n << " imax = " <<
imax;
cout << " pmax = " << p[imax] << endl;

// if imax = 0: n did not have any prime factors
in p[1..k]

// so n is a prime number. We return n
if (imax == 0) return n; // n is a prime number

return (n < p[imax]) ? p[imax] : n;

}

main() {
time_t t1,t2;
t1 = time(NULL);
BI r = Euler03(x); // 6857
t2 = time(NULL);
float d = difftime(t2,t1);// sec.
cout << endl << " Time: " << d << " sec. " << endl;
cout << "nn The result: " << r;
cin.get();
return 0;

}

Euler04

A palindromic number reads the same both ways. The largest palindrome made from the
product of two 2-digit numbers is 9009 = 91 99.

Find the largest palindrome made from the product of two 3-digit numbers.

/*
Copyright: NXH 2010
Date: 10/06/10 10:53
Description:
Euler04
A palindromic number reads the same both ways. The
largest palindrome made from the product of two 2-
digit numbers is 9009 = 91 99.
Find the largest palindrome made from the product of
two 3-digit numbers.

*/

#include <iostream>
#include <stdio.h>;


int Exp(int a, int x) {
int z = 1;
while (x) {
if (x % 2 == 1) z *= a;
a = a * a;
x /= 2;
}
return z;
}

int Rev(int z) {
int x = 0;
while(z) {
x = x * 10 + (z % 10);
z /= 10;
}
return x;
}

void Euler04(int digitNumber, int & x, int & y) {
int maxNum = Exp(10,digitNumber) - 1;
int z;
for (x = maxNum; x >= 0; --x)
for (y = maxNum; y >= 0; --y){
z = x*y;
if (z == Rev(z)) return;
}
}

main() {
int x, y;
Euler04(3,x,y);
cout << endl << x << " * " << y << " = " << (x * y);
// x = 999, y = 91, x*y = 90909
cin.get();
return 0 ;
}

1. 9 * 1 = 9
2. 99 * 91 = 9009
3. 995 * 583 = 580085
4. 9999 * 9901 = 99000099

Euler69

Euler's Totient function, φ(n) [sometimes called the phi function], is used to determine the number of
numbers less than n which are relatively prime to n. For example, as 1, 2, 4, 5, 7, and 8, are all less than
nine and relatively prime to nine, φ(9)=6.
n Relatively Prime Φ(n) n/φ(n)
2 1 1 2
3 1,2 2 1.5
4 1,3 2 2
5 1,2,3,4 4 1.25
6 1,5 2 3
7 1,2,3,4,5,6 6 1.1666...
8 1,3,5,7 4 2
9 1,2,4,5,7,8 6 1.5
10 1,3,7,9 4 2.5
It can be seen that n = 6 produces a maximum n/φ(n) for n 10.
Find the value of n 1,000,000 for which n/φ(n) is a maximum.
n = 100000 (một trăm ngàn); max phi(i)/i = 5.21354 đạt tại i = 30030; 1 sec.
n = 1000000 (một triệu) ; max phi(i)/i = 5.53939 đạt tại i = 510510 dưới 1 sec.
Nhận xét 1
Nếu n = p1m1 p2m2 … pkmk thì (n) = p1m1−1 p2m2−1 … pkmk−1.(p1−1)(p2−1)…(pk−1).
Do đó , kí hiệu E(n) = n/(n), ta có
E(n) = n/(n) = (p1p2…pk)/((p1−1)(p2−1)…(pk−1)) (*)
Kí hiệu S(n) là tập các ước nguyên tố (khác nhau) của n, thí dụ, n = 60 thf S(n) = { 2, 3, 5 }. Công thức (*)
cho ta biết, nếu hai số tự nhiên n và m có S(n) = S(m) thì E(n) = E(m). Thí dụ, n = 10i và m = 10j sẽ cho
cùng giá trị E vì S(n) = S(m) = { 2, 5 }.
Xét dãy liên tiếp các số nguyên tố pi 2, 3, 5,…
Vì p < q suy ra pq−q < pq − p hay q(p−1) < p(q−1) tức q/(q−1) < p/(p−1). Vậy dãy pi/(pi-1) với i = 1, 2
giảm dần: pi/(pi-1) < pi+1/(pi+1-1).
Vậy tích p1/(p1-1) * p2/(p2-1) * … * pk/(pk-1) đạt max khi tích p1p2…pk là số lớn nhất không vượt quá n.
/*
Copyright: NXH 2010
Date: 10/06/10 10:53
Description:
It can be seen that n=6 produces a maximum n/phi(n) for n <=
10.
Find the value of n <=1,000,000 for which n/phi(n) is a
maximum.

*/

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <time.h>



UI p[10];

inline UI Min(UI a, UI b) { return ( a <= b) ? a : b; }

bool IsPrime(UI y) {
UI ys = (UI)(sqrt(y));
for (UI d = 1; p[d] <= ys; ++d)
if (y % p[d] == 0) return false;
return true;
}

inline UI NextPrime(int k) {
for (k = p[k] + 2; !IsPrime(k); k += 2);
return k;
}

float Euler69(UI n, UI & a) {
int k = 2;
UI m;
UI b;
p[1] = 2; p[2] = 3;
a = p[1]*p[2]; b = (p[1]-1)*(p[2]-1);
while (a < n) {
m = NextPrime(k);
p[++k] = m;
a *= m; b *= (m-1);
}
if (a > n) { a /= m; b /= (m-1); --k; }
cout << endl << " Found " << k << " prime numbers " << endl;
for (int i = 1; i <= k; ++i) cout << p[i] << " ";
return (float) a/b;
}

void Test() {
time_t t1,t2;
t1 = time(NULL);
UI n;
float r = Euler69(1000000, n);
cout << endl << " result: n/phi(n) = " << r << " n = " <<
n;
t2 = time(NULL);
}

main() {
Test();
cout << (UI)(2*3*5*7*11*13*17*19);

cin.get();
return 0;
}

Problem 5
30 November 2001

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any
remainder.

What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

Problem 6
14 December 2001

The sum of the squares of the first ten natural numbers is,
12+ 22 + ... + 102 = 385
The square of the sum of the first ten natural numbers is,
(1 + 2 + ... + 10) 2 = 552= 3025
Hence the difference between the sum of the squares of the first ten natural numbers and the square of the
sum is 3025 − 385 = 2640.
Find the difference between the sum of the squares of the first one hundred natural numbers and the square
of the sum.
2 phương án.
Phương án 1. Tính theo 2 vòng lặp, O(n2).
Phương án 2. O(n).
Các công thức:

n
S (i )  i  k
k  i 1

S(i) = i((i+1) + (i+2) + … + n) _(a1 + a2 + … + am)2 = a12 + a22 + … + an2 + a1a2 + a1a3 + … +a1an
// Find the sum of all the primes below two million.
#include <iostream>
#include <math.h>

const int mn = 200;
int a[mn];

int Diff1(int n) {
int s = 0;

int i, j;
for (i = 1; i < n; ++i)
for(j = i+1; j <= n; ++j) s += i*j;
return 2*s;
}

int Diff2(int n) {
int s;
int i;
a[n] = n;
for (i = n-1; i > 0; --i) a[i] = i+a[i+1];
s = a[2];
for(i = 2; i < n; ++i) s += i*a[i+1];
return 2*s;
}

main() {
cout << endl << Diff1(100);
cout << endl << Diff2(100);

return 0;
}

Problem 7
28 December 2001
By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13. What is the
10001th prime number?
Phương án 1. Sàng, sau đó duyệt để lấy số thứ n. Trong khoảng 1..200000 có 17984 số nguyên tố.
Phương án 2. NextPrime sinh số nguyên tố sát sau.

// Find the 10001-th prime number.

#include <iostream>
#include <math.h>

const int mn1 = 200000;
const int mn2 = 20000;

char p[mn1+1];
int a[mn2];

void Eratosthenes(int n) {
int i, j, n2, c = (int)sqrt(n);
for (i = 2; i < c; ++i)
if (p[i] == 0) {
n2 = n/i;
for (j = i; j <= n2; ++j) p[i*j] = 1;
}
}

int PrimeN1(int n) { // phuong an 1
int d = 0;

Eratosthenes(mn1);
for (int i = 2; i < mn1; ++i)
if (p[i] == 0) {
++d;
if (d == n) return i;
}
}

bool IsPrime(int m) {
int sq = (int)sqrt(m);
int i;
for (i = 1; a[i] <= sq; ++i)
if (m % a[i] == 0) return false;
return true;
}

// Biet k so nguyen to.
// Yim so thu k+1
int NextPrime(int k) {
int m = a[k];
do {
m += 2;
} while (!IsPrime(m));
return m;
}

int PrimeN2(int n) {
a[1] = 2; a[2] = 3; // Khoi tri voi 2 so ng to dau tien
int k = 2, m;
for (int i = 1; i <= n; ++i) {
m = NextPrime(k);
a[++k] = m;
}
return a[n];
}

main() {
cout << endl << PrimeN1(10001); // 104743
cout << endl << PrimeN2(10001); // 104743

return 0;
}

Problem 8
11 January 2002
Find the greatest product of five consecutive digits in the 1000-digit number.

73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866

70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450

Biến thể 1. Tính tổng max của k phần tử liên tiếp. Cửa sổ trượt.

// Find the greatest sum of k consecutive digits
// in the n-digit number.

#include <iostream>
#include <fstream>
#include <stdio.h>
#include <math.h>
#include <time.h>


const char * fn = "Euler8.txt";

char a[mn];
int n; // so luong phan tu
int k; // chieu dai doan

inline bool IsDigit(char c) { return (c >= '0' && c <= '9'); }

void ReadData() {
ifstream f(fn);
int i = 0;
char c;
while (!f.eof()) {
f >> c;
if (IsDigit(c)) a[++i] = c-'0';
}
f.close();
for (i = 1; i <= n; ++i) cout << (int)a[i];
}

inline int Max(int a, int b) { return (a > b) ? a : b; }

int Sum() {
int s = 0, smax;
int i, j;
// Sum of the first k elements

for (i = 1; i <= k; ++i) s += a[i];
smax = s; i = 1;
for (j = k + 1; j <= n; ++j,++i) {
s = s + a[j] - a[i];
smax = Max(smax,s);
}
return smax;
}

main() {
time_t t1,t2;
t1 = time(NULL);
ReadData();
cout << endl << endl << Sum() << endl;
t2 = time(NULL);
cin.get();
return 0;
}

Biến thể 2. Tích max của k phần tử liên tiếp. Cửa sổ trượt.

// Find the greatest product of k consecutive digits
// in the n-digit number.

#include <iostream>
#include <fstream>
#include <stdio.h>
#include <math.h>
#include <time.h>



char a[mn];


void ReadData() {
ifstream f(fn);
f >> n >> k; cout << endl << " n = " << n << " k = " << k <<
endl;
int i = 0;
char c;
while (!f.eof()) {
f >> c;
}
f.close();

}


int Product() {
int s , smax = 0 ;
int i, j, d;
s = 1;
for (j = 1; j <= k; ++j) s *= a[j];
smax = Max(smax,s);
i = 1;
for (j = k+1; j <= n; ++j, ++i) {
if (a[i] > 0) s /= a[i];
else { // a[i] = 0
s = 1;
for (d = i+1; d < j; ++d) s *= a[d];
}
s *= a[j];
smax = Max(s,smax);
}
return smax;
}

main() {
time_t t1,t2;
t1 = time(NULL);
ReadData();
cout << endl << endl << Product() << endl;
t2 = time(NULL);
cin.get();
return 0;
}

Cải tiến biến thể 2. loại trừ nhưnTích max gx a[j] = 0.
Ch][ng trinhf tinhs car 2 ph][ng ans vaf xacs ddinhj vị trì jmax (phần tử cuối dãy đạt tích max).

// Find the greatest sum of k consecutive
// digits in the n-digit number.

#include <iostream>
#include <fstream>
#include <stdio.h>
#include <math.h>
#include <time.h>



char a[mn];
int jmax;


void ReadData() {
ifstream f(fn);
f >> n >> k; cout << endl << " n = " << n << " k = " << k <<
endl;
int i = 0;
char c;
while (!f.eof()) {
f >> c;
}
f.close();
}


int Product1() {
int s , smax = 0 ;
int i, j, d;
s = 1;
for (j = 1; j <= k; ++j) s *= a[j];
if (smax < s) { smax = s; jmax = k; }
i = 1;
for (j = k+1; j <= n; ++j, ++i) {
if (a[i] > 0) s /= a[i];
else { // a[i] = 0
s = 1;
for (d = i+1; d < j; ++d) s *= a[d];
}
s *= a[j];
if (smax < s) { smax = s; jmax = j; }
}
return smax;
}

int Product2() {
int s , smax = 0 ;
int i = 0, j, d;
s = 1; d = 0;
for (j = 1; j <= n; ++j) {
if (a[j] == 0) {
i = j; s = 1; d = 0;
}
else { // s[j] > 0
s *= a[j];
++d;
if (d == k) {
if (smax < s) { smax = s; jmax = j; }
++i; s /= a[i]; --d;
}

}
}
return smax;
}

main() {
float d;
time_t t1,t2;
ReadData();
t1 = time(NULL);
cout << endl << endl << Product1() << " jmax = " << jmax <<
endl;

t2 = time(NULL);
d = difftime(t2,t1);// sec.

t1 = time(NULL);
cout << endl << endl << Product2() << " jmax = " << jmax <<
endl;

t2 = time(NULL);

cin.get();
return 0;
}

Problem 9
25 January 2002

A Pythagorean triplet is a set of three positive integes (a, b, c), for which,
a2 + b2 = c2.
For example, 32 + 42 = 52 ( 9 + 16 = 25).
There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product abc.
Nhận xét

1. Trong bộ ba Pithagor không có 2 số bằng nhau. Nếu a = b thì c  2 a là số vô tỷ, không phải số
nguyên. Nếu a = c thì b = 0, nếu b = c thì a = 0. Từ nhận xét này ta có thể quy định 0 < a < b < c.
2. Nếu tổng a+b+c = k thì nhận xét 1 cho ta 1 ≤ a ≤ m, a+1 ≤ b ≤ 2m, c = k−a−b; m = k/3.

/*−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
There exists exactly one Pythagorean triplet
for which a + b + c = 1000.

Find the product abc.
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−-*/
#include <iostream>
#include <stdio.h>


int Pit() {
const int k = 1000;
int a, b, c, c2, a2, ab2, lim, lim2;
lim = k/3; lim2 = 2*lim;
for (a = 1; a <= lim; ++a) {
a2 = a*a;
for (b = a+1; b <= lim2; ++b) {
ab2 = a2 + b*b;
c = k - a - b;
c2 = c*c;
if (c*c == ab2)
return (a * b * c);
}
}
return 0;
}

main() {
cout << endl << Pit();
cin.get();
return 0;
}

Problem 10
08 February 2002
The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
Find the sum of all the primes below two million.
// Find the sum of all the primes below two million.

#include <iostream>
#include <math.h>

char a[mn];

void Eratosthenes(int n) {
int i, j, n2, c = (int)sqrt(n);
memset(a,0,sizeof(a));
for (i = 2; i < c; ++i)
if (a[i] == 0) {
n2 = n/i;
for (j = i; j <= n2; ++j) a[i*j] = 1;
}
}

unsigned int Sum(int n) {

unsigned int s = 0;
Eratosthenes(n);
for (int i = 2; i <= n; ++i)
if (a[i] == 0) s += i;
return s;
}

main() {

int n = mn-1;
cout << Sum(n); // 1179908154
return 0;
}

Problem 11
22 February 2002

In the 20 20 grid below, four numbers along a diagonal line have been marked in red.

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

The product of these numbers is 26 63 78 14 = 1788696.

What is the greatest product of four adjacent numbers in any direction (up, down, left, right, or diagonally)
in the 20 20 grid?

Problem 14
05 April 2002

The following iterative sequence is defined for the set of positive integers:
n → n/2 (n is even)
n → 3n + 1 (n is odd)
Using the rule above and starting with 13, we generate the following sequence:
13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1
It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not
been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.
Which starting number, under one million, produces the longest chain?
NOTE: Once the chain starts the terms are allowed to go above one million.
Đề: Collatz Problem (Bài toán 3n+1).
Với mỗi số tự nhiên n ta thực hiện các thao tác sau để sinh ra dãy số:
Nếu n lẻ thì thay n bằng 3n+1; ngược lại, nếu n chẵn thì thay nn bằng n/2.
Xác định số n  1000000 (1 triệu) để dãy số sinh ra là dài nhất.
Đáp số: n = 837799 sinh dãy dài 525 số.

Chú ý rằn có thể lúc đầu giá trị n nhỏ (dưới 1 triệu), nhưng sau một số bước giá trị này có thể tăng lên đến
vài tỷ. Thí dụ,
837799 → 2513398 → 1256699→ 3770098→ 1885049→ 5655148→ 2827574→ 1413787→ 4241362
→ 2120681→ 6362044→ 3181022→ 1590511→ 4771534→ 2385767→ 7157302→ 3578651
→ 10735954→ 5367977→ 16103932→ 8051966→ 4025983→ 12077950→ 6038975→ 18116926
→ 9058463→ 27175390→ 13587695→ 40763086→ 20381543→ 61144630→ 30572315→ 91716946
→ 45858473→ 137575420→ 68787710→ 34393855→ 103181566→ 51590783→ 154772350
→ 77386175→ 232158526→ 116079263→ 348237790→ 174118895→ 522356686→ 261178343
→ 783535030→ 391767515→ 1175302546.
Thuật toán
Ta tạm gọi dãy sinh ra là dãy 3n+1
Nhận xét.
1. Dãy 3n+1 là dãy không lặp, do đó sinh xuôi và sinh ngược đều các dãy không lặp
Phương án 1: vét
Ta duyệt với mỗi n = 2..1000000 xác định chiều dài lớn nhất của dãy thu được theo quy tắc ra trong đề bài.
Để ý rằng khi n lẻ ta tính n’ = 3n+1. Ta thấy n’ chẵn và n’ > n trong khi ta cần dãy giảm đến 1. Vì vậy, khi
n lẻ ta tính luôn 2 bước n’ = 3n+1 và n’’ = n’/2 = 2n/2 + (n+1)/2 = n + (n+1)/2. Với thời gian không quá 1’’
bạn có thể tìm ra đáp số n = 837799 đạt chiều dài max = 525.
Để ý rằng nếu n chẵn thì s(n) = s(n/2) + 1
n lẻ thì s(n) = s(n+(n+1)/2) + 2;
Nên chạy trong Turbo Pascal vì Free Pascal không ổn định.
Thay n/2 bằng n >> 1 sẽ nhanh hơn là dùng phép chia.
(*------------------------------------------------
Problem Euler 14 Ver. 1

Find an integer n under one million that generates
the longest chain by the following rule
if n is even then replace n by n/2
else replace n by 3n + 1
--------------------------------------------------*)

const mn = 1000000;

function Try(n: longint): longint;
var d: longint;
begin
d := 1;
while (n > 1) do
if Odd(n) then
begin
d := d+2;
n := n+((n+1) shr 1);
end
else
begin
inc(d);
n := n shr 1;
end;
Try := d;
end;

procedure Find(mn: longint);
var i, d, dmax, imax: longint;
begin
dmax := 1; imax := 1;
for i := 2 to mn-1 do
begin
d := Try(i);
if (d > dmax) then
begin
dmax := d; imax := i;
end;
end;
writeln(dmax,' ', imax);
end;

BEGIN
Find(mn);
readln;
END.

/*------------------------------------------------
--------------------------------------------------*/

#include <iostream>
#include <fstream>

#define Odd(n) (((n) & one) == one)


typedef unsigned int UI;

const UI mn = 1000000;
const UI one = (UI)1;

int Try(UI n) {
int d = 1;
while (n > 1) {
if (Odd(n)) { d += 2; n = n+((n+1)>>1); }
else { d++; n >>= 1; }
}
return d;
}

void Find(int mn) {
UI i;
int d, dmax = 1, imax = 1 ;
for (i = 2; i < mn; ++i) {
d = Try(i);
if (d > dmax) {
dmax = d; imax = i;
}
}
}

main() {
float d;
time_t t1,t2;
t1 = time(NULL);
Find(mn);
t2 = time(NULL);
cin.get();
return 0;
}

Phương án 2. Dùng quy hoạch động hạn chế.
Kí hiệu s(n) là chiều dài dãy 3n+1. Ta có ngay:
s(n) = s(n/2) + 1, nếu n chẵn
s(n) = s(n+(n+1)/2) + 2, nếu n lẻ
Ta sử dụng mảng a gồm mn = 1 triệu phần tử, a[i] = s(i) và sẽ lặp cho đến khi n < mn để đánh dấu

/*--------------------------------------------------------
--------------------------------------------------------*/
#include <iostream>
#include <fstream>

#define Odd(n) (n & 1) == 1
#define Even(n) !Odd(n)




UI a[mn];

int Try(UI n) {
int d = 1, v = n;
if (Even(v)) {
a[n] = a[v/2] + 1; return a[n];
}
while (v > 1) {
if (Odd(v)) { d += 2; v += ((v+1)>>1); }
else { d++; v >>= 1; }
if (v < n) {
if (a[v] > 0) {
a[n] = a[v] + d - 1;
return a[n];
}
}
}
a[n] = d;
return a[n];
}

int Test(UI n) {
int d = 1;
while (n > 1) {
if (Odd(n)) { d += 2; n += ((n+1)>>1); }
else { d++; n >>= 1; }
}
return d;
}

void Find(int mn) {
UI i;
int d, dmax = 1, imax = 1;
a[1] = 1;

for (i = 2; i < mn; ++i) {
d = Try(i);
if (d > dmax) {
dmax = d; imax = i;
}
}

}

main() {
float d;
time_t t1,t2;
t1 = time(NULL);
Find(mn);
t2 = time(NULL);
cin.get();
return 0;
}

Phương án 3.
FromOne: Sinh dãy ngược từ 1. Đánh dấu độ dài của các phần tử được sinh mới trong dãy.
Sau đó duyệt lại mảng, xét những phần tử chưa đánh dấu ta sinh xuôi dãy và cũng đánh dấu các phần tử
được sinh trong dãy.

/*------------------------------------------------
--------------------------------------------------*/
#include <iostream>
#include <fstream>

#define Odd(n) (n & 1) == 1
#define Even(n) !Odd(n)



const UI mn2 = mn+2;

UI len[mn];
UI q[mn];
UI v,r; // con tro ngan xep st
UI lenmax, imax;

void FromOne() {
UI x, y;
UI s;

memset(len,sizeof(len),0);
v = r = 0; len[1] = 1;
q[++v] = 1;
do {
x = q[++r]; s = len[x];
y = 2*x;
if (y < mn)
if (!len[y])
{ len[y] = s+1; q[++v] = y; }
if (Even(x)&&((x-1)%3==0)) {
y = (x-1)/3;
if (!len[y])
{ len[y] = s+1; q[++v] = y; }
}
} while (v != r);
lenmax = s ; imax = x;
}

void ToOne(UI n) {
int d = 1;
int x = n;
int s, i;
q[d] = n;
if (Even(x)) {
len[n] = len[x/2] + 1;
if (lenmax < len[n]) {
lenmax = len[n];
imax = n;
}
return;
}
while (x > 1) {
if (Odd(x)) { q[++d] = 3*x+1; x = q[d]/2; q[++d] = x; }
else { x >>= 1; q[d++] = x; }
if (x < mn)
if (len[x]) {
len[n] = len[x] + d - 1;
if (lenmax < len[n]) {
lenmax = len[n];
imax = n;
}
s = len[n]+1;
for (i = 2; i <= d; ++i)
if (q[i] < mn) len[q[i]] = s-i;
return;
}
}
}

void Find() {
UI i;
FromOne();
for (i = 2; i < mn; ++i)
if (len[i] == 0) ToOne(i);
cout << endl << " lenmax = " << lenmax << " imax = " <<
imax;
}

main() {
float d;
time_t t1,t2;
t1 = time(NULL);
Find();
t2 = time(NULL);
cin.get();
return 0;
}

Problem 15
19 April 2002
Starting in the top left corner of a 2 2 grid, there are 6 routes (without backtracking) to the bottom right
corner.

How many routes are there through a 20 20 grid?
Thuật toán
Ta giải bài toán tổng quát với lưới đơn vị gồm chiều dài n, rộng m. Trên lưới vuông này ta đánh nhãn các
cạnh đơn vị nằm ngang là D, dọc là R. Mọi đường đi không quay lui từ góc trên trái đến góc dưới phải đều
phải qua đúng n cạnh ngang và m cạnh dọc. Bài toán quy về dạng tổ hợp như sau. Có thể xây dựng bao
nhiêu xâu kí tự độ dài n+m từ hai kí tự D và R trong đó có đúng n kí tự D và m kí tự R. Như vậy ta chỉ cần
chọn đúng n vị trí trong số các vị trí từ 1..(n+m) để điền kí tự D. Các vị trí còn lại ta điền kí tự R.Vậy đáp
số sẽ là tổ hợp chặp 2 của 2n
Cnn+m = (n+m)!/(n!m!) = ((n+1)(n+2)...(n+m))/m! (*)
Với n = m = 20 ta phải tính toán với các số lớn của tử và mẫu số trong công thức (*). Ta chọn phương pháp
tính khác, cụ thể là ta dùng tam giác Pascal. Tam giác Pascal có những tính chất sau :
(T1) Dòng thứ n có n+1 phần tử mã số từ 0 đến n.
(T2) Phần tử thứ k trên dòng n, Ckn = tổ hợp chặp k của n phần tử = số hạng thứ k trong dạng khai
triển của nhị thức (a+b)n = tổng của số hạng thứ k và k-1 trên dòng sát trước, dòng n-1 (Ckn= Ckn-1
+ Ck-1n-1).
(T3) Mỗi dòng là một dãy số được bố trí đối xứng nhau. Tính chất này cho phép ta chỉ cẫn xác
định các giá trị trên một nửa dòng.
2 11
3 121
4 1331
5 14641
6 1 5 10 10 5 1

7 1 6 15 20 15 6 1

// Problem Euler 15
#include <iostream>
#define Even(c) ((c)&1)==0
#define Odd(c) !Even(c)
const int maxN = 21;
int a[maxN];
int Pas(int n, int m) {
int nm = n+m, i, i2, j;
a[0] = a[1] = 1;
for (i = 2; i <= nm; ++i) {
i2 = i/2;
a[i2] = (Odd(i)) ? a[i2]+a[i2-1] : 2*a[i2-1];
for (j = i2-1; j > 0; --j)
a[j] = a[j]+a[j-1];
}
return (n < m) ? a[n] : a[m];
}
main() {
cout << endl << Pas(2,2); // 407575348
cin.get();
return 0;
}

Problem 16
03 May 2002
215 = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.
What is the sum of the digits of the number 21000?
Thuật toán Tính trực tiếp.
Khởi trị a = 2;
lặp n lần a = a * 2;
// Problem Euler 16
// Tính tong cac chu so cua so 2^1000

#include <iostream>

int a[maxN];
int len;


// 2^1
void Init() {
a[0] = 2;
len = 1;
}

// a = 2*a
void Mult2() {
int c = 0;
for (int i = 0; i < len; ++i) {
c = (a[i]<<1) + c;
a[i] = c % 10;
c /= 10;
}
if (c) a[len++] = c;
}

int Sum(int n) {
int i,s = 0;
Init();
for (i = 2; i <= n; ++i)
Mult2();
for (i = 0; i < len ; ++i) s += a[i];
return s;
}

main() {
cout << endl << Sum(1000) << " len = " << len; // 1366, 302 chu
so
cin.get();
return 0;
}

Viết dãy số
Nếu sử dụng các tấm bìa, trên mỗi tấm ghi 1 chữ số thì đê ghi liên tiếp các số từ 1 đến 10 ta cần 21 tấm.

1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1 4 1 5

Cần bao nhiêu bìa để viết các số từ 1 đến 1000?

Problem 18
31 May 2002

By starting at the top of the triangle below and moving to adjacent numbers on the row below, the
maximum total from top to bottom is 23.

3
7 4
2 4 6
8 5 9 3

That is, 3 + 7 + 4 + 9 = 23.

Find the maximum total from top to bottom of the triangle below:

75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 16 70 92
41 41 26 56 83 40 80 70 33
41 48 72 33 47 32 37 16 94 29
53 71 44 65 25 43 91 52 97 51 14
70 11 33 28 77 73 17 78 39 68 17 57
91 71 52 38 17 14 91 43 58 50 27 29 48
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23

NOTE: As there are only 16384 routes, it is possible to solve this problem by trying
every route. However, Problem 67, is the same challenge with a triangle containing one-
hundred rows; it cannot be solved by brute force, and requires a clever method!)

Thuật toán

Đọc dần dữ liệu tính trọng số tại mỗi đỉnh k. Đỉnh trên cạnh (nằm ngoài cùng ở 2 đầu) chỉ
có 1 cha. Đỉnh trong có 2 cha.

Nếu k là đỉnh đầu tiên của dòng i thì cha của k là k-i+1. Nếu k là đỉnh cuối cùng của dòng
i thì cha của k là k-i. Nếu đỉnh k nằm giữa dòng i thì k có 2 cha là k-i và k-i+1.

// Problem Euler 16
// Tính tong cac chu so cua so 2^1000

#include <iostream>
#include <fstream>

#define Max(a,b) ((a > b) ? a : b)

const char * fn = "E18.inp";
int a[maxN];


int MaxTotal(){
int n, i, j, x, k = 1, maxval = 0;
ifstream f(fn);
f >> n;
f >> x; a[k] = x;
for (i = 2; i <= n; ++i) {
f >> x; ++k; a[k] = a[k-i+1]+x;
for (j = 2; j < i; ++j) {
f >> x; ++k; a[k] = Max(a[k-i],a[k-i+1]) + x;
}

Sang tao4

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (15)

Destaque

Destaque (20)

Semelhante a Sang tao4

Semelhante a Sang tao4 (20)

Último

Último (20)

Sang tao4