Blog Thuật toán

SPOJ.COM - Thuật toán bài PRADIPSUM - Easy Math

admin@phamvanlam.com — Wed, 17 Oct 2018 06:58:00 GMT

Đề bài:

Zoro là một học sinh tiểu học. Cậu ta thích giải toán. Một ngày nọ, Zoro thử giải một bài toán. Nhưng cậu ta không thể giải quyết nó một cách hiệu quả bởi vì mới học tiểu học. Vì bạn là một lập trình viên, nên cậu ta muốn nhờ bạn giúp đỡ bài toán này. Và vấn đề ở đây là tính tổng của các số liên tiếp.

Ví dụ: Nếu số thứ nhất là 2 và số tiếp theo là 5, thì kết quả sẽ là: 2 + 3 + 4 + 5 = 14.

Đầu vào

Mỗi dòng chứa 2 số a và b. Đầu vào kết thúc bởi kí tự kết thúc file.

Đầu ra

In ra tổng của các số liên tiếp giữa a và b (bao gồm cả 2 số đó).

Ràng buộc

-10^8  ≤ (a , b) ≤ 10^8

Ví dụ

Input:

2 5
5 10

Output:

14
45

Phân tích bài toán

Bài này yêu cầu tính tổng của 2 số a và b. Dĩ nhiên bạn có thể sử dụng một vòng lặp for để duyệt và tính tổng các số. Lúc này, độ phức tạp sẽ là: 10^8. Nên thời gian chạy chắc chắn sẽ dưới 2 giấy.

Tuy nhiên, để nhanh hơn thì mình có thể sử dụng công thức tính tổng của cấp số cộng:

T(n) = n * (a(1) + a(n)) / 2

Trong đó: (giả sử a < b)

n là số lượng các số => n = b - a + 1
a(1) là số đầu tiên => a(1) = a
a(n) là số cuối cùng => a(n) = b

Đến đây thì bạn đã có thể tính ra kết quả được rồi.

Tuy nhiên, có 2 vấn đề mà bạn cần phải biết để giải quyết bài toán này:

Giá trị của a và b chưa biết trước nên có thể a < b hoặc ngược lại a > b.
Vì đầu bài không cho trước số lượng test case nên cách tốt nhất để quét hết các trường hợp là sử dụng cin >> a >> b. Nếu còn test case thì kết quả của phép nhập này là true, ngược lại là false.

Qua phân tích như vậy, mình sẽ triển khai code như sau.

Lời giải

Bạn nên tự mình nghĩ ra thuật toán của bài toán trước khi tham khảo code của mình nhé. Hãy phát huy tối đa khả năng sáng tạo của bản thân. Hơn nữa code mình viết ra cũng chưa thật sự tối ưu. Nên rất mong nhận được sự chia sẻ của bạn.

#include <iostream>
using namespace std;

long long sumAll(long long a, long long b) {
	long long n;

	if (b > a) n = b - a + 1;
	else n = a - b + 1;

	return n * (a + b) / 2;
}

int main() {
	ios::sync_with_stdio(false);
	//freopen("input.txt", "r", stdin);

	int a, b;
	while(cin >> a >> b) {
	  cout << sumAll(a, b) << endl;
	}

  return 0;
}

SPOJ.COM - Thuật toán bài NABILHACKER - Hack the Password

admin@phamvanlam.com — Wed, 10 Oct 2018 06:58:00 GMT

Đề bài:

Rất nhiều người hỏi mình về vấn đề áp dụng lập trình ở cuộc thi vào các project trong đời sống thực chất là gì? Điều này có vẻ không mấy thú vị. Cái mà mình thấy thực sự thú vị đó là, vào một ngày nọ, một người bạn - là hacker đã đến gặp mình. Anh ta yêu cầu mình giải quyết một bài toán về hacking của anh ấy.

Khi bạn muốn lấy cắp mật khẩu của ai đó, bạn có thể cài đặt chương trình KeyLogger trên máy tính của người đó. KeyLogger sẽ đưa cho bạn một string đóng vai trò là password. Nhưng có một vấn đề, đó là nó sẽ đưa cho bạn tất cả mọi thứ mà nạn nhân đã gõ, bao gồm cả phím dịch trái, dịch phải, backspace.

Giả sử nạn nhân gõ password "generio312", nhưng dựa trên kịch bản là:

Anh ta gõ "generio1"
Sau đó, anh ta nhấn nút dịch trái, và nhấn 3. Lúc này password sẽ là "generio31"
Rồi anh ta nhấn dịch phải, và nhấn 2. Lúc này password là "generio312"
Cuối cùng anh ta nhấn "ghj" và nhấn backspace 3 lần để xoá 3 kí tự này đi. Vì vậy, password cuối cùng sẽ là "generio312".

Tuy nhiên, như mình đã nói, KeyLogger sẽ đưa cho bạn tất cả những gì mà anh ta gõ. Do đó, bạn sẽ nhận được string là "generio1<3>2ghj---". Trong đó, < là dịch trái, > là dịch phải và - là backspace.

Đầu vào

Tại vị trí đầu tiên của input là số T, số lượng của testcase. Sau đó, có T string s, với độ dài 1 <= |s| <= 10^6. Mỗi string sẽ bao gồm chữ cái in hoa, chữ cái in thường, dấu <, dấu &gt, dấu - và các số [0, 9]

Đầu ra

Đầu ra sẽ là một string ở mỗi dòng - tương ứng với password.

Ví dụ

Input:

2
<<BP<A>>Cd-
ThisIsS3Cr3t

Output:

BAPC
ThisIsS3Cr3t

Phân tích bài toán

Đầu tiên, khi đọc bài toán này, mình nghĩ ngay đến việc sử dụng List. Nhưng không phải là Singly Linked List mà mình cần có một con trỏ để xác định vị trí hiện tại - nơi mà mình sẽ thực hiện các hành động (dịch trái, dịch phải, xóa, chèn thêm 1 kí tự).

Tuy nhiên, cách này sẽ bị lâu ở chỗ là mình cần phải tạo thêm node, xóa node, thay đổi liên kết của node. Vì vậy, mình nghĩ đến cách thứ 2 đó là sử dụng 2 stack.

Vì mình thấy cách triển khai của bài này rất giống với cách triển khai thuật toán Undo-Redo.

Tư tưởng của thuật toán này là:

Giả sử mình có 2 stack là: stMain và stBuffer
Khi duyệt string input:
- Nếu là kí tự dịch trái (<): pop ở stMain rồi push vào stBuffer
- Nếu là kí tự dịch phải (>): pop ở stBuffer rồi push vào stMain
- Nếu là kí tự backspace (-): pop ở stMain
- Nếu là kí tự còn lại: push vào stMain
Sau khi duyệt hết string input: mình chỉ cần ghép stMain và stBuffer vào là được.

Kể ra có cái hình vẽ minh họa thì bạn sẽ dễ hiểu hơn mà mình lười vẽ quá, nên thôi vậy. Bạn chịu khó xem cách mình triển khai code ở phía dưới.

Chỗ nào chưa hiểu thì bạn có thể hỏi mình bằng cách đặt bình luận phía dưới, mình sẽ cố gắng giải đáp.

Lời giải

Cách 1: Sử dụng List (0.13s / 12M)

#include <iostream>
using namespace std;

const int MAX_N = 1000001;
char input[MAX_N], output[MAX_N];

// Node
struct Node {
	char data;
	Node *next;
	Node *prev;
};

Node* initNode(char data = '\0') {
	Node* node = new Node;
	node->data = data;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

// List
struct List {
	Node* root;
	Node* current;
};

List* initList() {
	List* list = new List;
	list->root = initNode();
	list->current = list->root;
	return list;
}

void deleteList(List *list) {
	Node *root = list->root;

	while(root->next != NULL) {
		Node* tmp = root->next;
		root->next = root->next->next;
		delete tmp;
	}

	delete root;
	delete list;
}

void moveLeft(List *list) {
	Node *p = list->current->prev;
	if (p) list->current = p;
}

void moveRight(List *list) {
	Node *p = list->current->next;
	if (p) list->current = p;
}

void backspace(List *list) {
	if (list->current->prev) {
		Node *curr = list->current;
		Node *prev = curr->prev;
		Node *next = curr->next;

		if (prev) prev->next = next;
		if (next) next->prev = prev;

		list->current = prev;
		delete curr;
	}
}

void addItem(List *list, char data) {
	Node* node = initNode(data);
	Node* next = list->current->next;
	list->current->next = node;
	node->prev = list->current;
	node->next = next;
	if (next) next->prev = node;
	list->current = node;
}

void build(List *list, char *output) {
	Node *p = list->root;
	int index = 0;

	while(p->next != NULL) {
		output[index] = p->next->data;
		p = p->next;
		index++;
	}

	output[index] = '\0';
}

void getPassword(List *list, char* output, char* input) {
	int index = 0;
	char current = '\0';

	while(true) {
		current = input[index];
		if (current == '\0') break;

		if (current == '<') {
			moveLeft(list);
		} else if (current == '>') {
			moveRight(list);
		} else if (current == '-') {
			backspace(list);
		} else {
			addItem(list, current);
		}

		index++;
	}

	build(list, output);
}

int main() {
	ios::sync_with_stdio(false);
	//freopen("input.txt", "r", stdin);

	int T;
	cin >> T;

	for(int tc = 0; tc < T; tc++) {
		List *list = initList();
		cin >> input;
		getPassword(list, output, input);
		cout << output << endl;
		deleteList(list);
	}

	return 0;
}

Cách 2: Sử dụng Stack (0.02s / 4.7M)

// Using stack
#include <iostream>
using namespace std;

const int MAX_N = 1000001;
char input[MAX_N], output[MAX_N];

// Stack
struct Stack {
	char* data;
	int length;
};

Stack* initStack(int maxLength) {
	Stack* st = new Stack;
	st->data = new char[maxLength];
	st->length = 0;
	st->data[st->length] = '\0';
	return st;
}

void destroyStack(Stack *st) {
	delete[] st->data;
	delete st;
}

int getLength(Stack *st) {
	return st->length;
}

bool isEmpty(Stack *st) {
	return st->length == 0;
}

bool isFull(Stack *st) {
	return st->length == MAX_N;
}

void push(Stack *st, char data) {
	if (!isFull(st) && data != '\0') {
		st->data[st->length] = data;
		st->length++;
		st->data[st->length] = '\0';
	}
}

char pop(Stack *st) {
	if (!isEmpty(st)) {
		char data = st->data[st->length - 1];
		st->length--;
		st->data[st->length] = '\0';
		return data;
	}

	return '\0';
}
// End of Stack

int getLength(char *input) {
  int index = 0;
	while(input[index] != '\0') index++;
	return index;
}

void concat(char *output, char *input1, char *input2) {
	int index1 = 0;
	while(input1[index1] != '\0') {
		output[index1++] = input1[index1];
	}

	int index2 = getLength(input2) - 1;
	int cnt = 0;
	while(index2 >= 0) {
		output[index1 + cnt++] = input2[index2--];
	}

	output[index1 + cnt] = '\0';
}

void getPassword(char *output, char* input) {
	Stack* stMain = initStack(MAX_N);
	Stack* stBuffer = initStack(MAX_N);

	int index = 0;
	char current = '\0';

	while(true) {
		current = input[index];
		if (current == '\0') break;

		if (current == '<') {
			push(stBuffer, pop(stMain));
		} else if (current == '>') {
			push(stMain, pop(stBuffer));
		} else if (current == '-') {
			pop(stMain);
		} else {
			push(stMain, current);
		}

		index++;
	}

	concat(output, stMain->data, stBuffer->data);
	destroyStack(stMain);
	destroyStack(stBuffer);
}

int main() {
	ios::sync_with_stdio(false);
	//freopen("input.txt", "r", stdin);

	int T;
	cin >> T;

	for(int tc = 0; tc < T; tc++) {
		cin >> input;
		getPassword(output, input);
		cout << output << endl;
	}

	return 0;
}

SPOJ.COM - Thuật toán bài MMATRIX - SHIFT Operator on Matrix

admin@phamvanlam.com — Tue, 25 Sep 2018 06:58:00 GMT

Đề bài:

Cho ma trận A kích thước nxn gồm các số nguyên, ( 0 ≤ i < n, 0 ≤ j < n ). Thao tác SHIFT tại hàng i ( 0 ≤ i < n ) sẽ dịch các số ở hàng i sang phải 1 vị trí và số ở cột cuối cùng sẽ trở về đầu tiên.

Bạn có thể thực hiện SHIFT bao nhiêu lần cũng được.

Đặt Cj = A0,j + A1,j + ... + A(n-1),j và M = max {Cj|0 <= j < n } sau mỗi lần dịch chuyển. Cj là tổng các số ở cột j.

Tìm giá trị bé nhất của M.

Đầu vào

Gồm một vài test, dòng đầu mỗi test là số nguyên n. n dòng tiếp theo mỗi dòng chứa n số nguyên. Kết thúc các bộ test là số -1. Giả thiết là 1 ≤ n ≤ 7 và |Ai,j| < 10^4.

Ví dụ:

Đầu ra

Với mỗi bộ test, in ra giá trị nhỏ nhất của giá trị lớn nhất của tổng các số trên 1 cột.

Ví dụ:

11
15

Phân tích

Bài này thuộc chủ đề Vét cạn - Brute force nên đương nhiên sẽ phải dùng cách vét cạn. Tuy nhiên, vấn đề là nếu sử dụng thuật toán vét cạn thì độ phức tạp của nó là như thế nào, liệu có bị time limit hay không. Bây giờ, mình sẽ phân tích.

Bài toán cho SHIFT bao nhiêu lần cũng được, nhưng mình cần phải tính số lần SHIFT sao cho vét cạn được hết tất cả các trường hợp. Vì mỗi hàng của ma trận có n cột, nên ta có các trường hợp dịch với bước nhảy là: 0, 1, 2, ..., n - 1. Chú ý rằng: bước nhảy n sẽ giống với bước nhảy 0, bước nhảy n + 1 sẽ giống với bước nhảy 1,... Như vậy, mỗi hàng sẽ có n trường hợp dịch, mà ta có n hàng. Suy ra: tổng số trường hợp là n ^ n.
Với mỗi trường hợp dịch như thế, ta phải tìm tổng giá trị của mỗi cột, sau đó suy ra giá trị lớn nhất giữa chúng (M). Và khi đã tìm ra mỗi giá trị lớn nhất này, ta chỉ cần so sánh nó với giá trị nhỏ nhất của M hiện tại để tìm ra giá trị bé nhất của M. Nghĩa là ta phải duyệt toàn bộ ma trận, do đó, độ phức tạp cho công việc này là: n ^ 2.
Tổng hợp lại: độ phức tạp của thuật toán là: n ^ n x n ^ 2 = n ^ (n + 2).
Theo bài ra, giá trị lớn nhất của n là 7 => độ phức tạp = 7 ^ (7 + 2) = 7 ^ 9 = 40353607. Mà theo một nghiên cứu, khi độ phức tạp tính ra cỡ 10 ^ 9 thì thời gian thực thi mới hết khoảng 1 giây. Vì vậy, độ phức tạp mà mình tính ra như thế là hoàn toàn khả thi với ràng buộc của bài toán (time limit: 0.131s-1.079s).

Mời bạn theo dõi cách triển khai của mình.

Lời giải

#include <iostream>
using namespace std;

const int MAX_N = 7;
const int MAX_INT = (2 << 30) - 1;
const int MIN_INT = -(2 << 30);

int N = 0, result;
int A[MAX_N][MAX_N];
int temp[MAX_N];

/**
* Tìm ra giá trị lớn nhất của mỗi cột
*/
int maxOfColumnSum() {
	int M = MIN_INT;

	for (int c = 0; c < N; c++) {
		int colSum = 0;

		for (int r = 0; r < N; r++) {
			colSum += A[r][c];
		}

		if (colSum > M) M = colSum;
	}

	return M;
}

void shift(int r, int step) {
	// copy sang mảng trung gian
	for (int j = 0; j < N; j++) {
		temp[(j + step) % N] = A[r][j];
	}

	// copy ngược lại mảng A giá trị của hàng r sau khi dịch chuyển
	for (int j = 0; j < N; j++) {
		A[r][j] = temp[j];
	}
}

void unshift(int r, int step) {
	// Dịch ngược step đơn vị giống với dịch xuôi (N - step) đơn vị
	shift(r, N - step);
}

void scan(int r) {
	// Điều kiện dừng
	if (r == N - 1) {
		int M = maxOfColumnSum();
		if (M < result) result = M;
		return;
	}

	for (int step = 0; step < N; step++) {
		// Dịch hàng r với bước nhảy step
		shift(r, step);

		scan(r + 1);

		// Trả lại trạng thái của hàng r
		// bằng cách dịch ngược lại với bước nhảy step
		unshift(r, step);
	}
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios::sync_with_stdio(false);

	while (true) {
		// Nhập giá trị của N và ma trận A
		cin >> N;
		if (N == -1) break;

		// Khởi tạo giá trị của result ứng với mỗi test case
		result = MAX_INT;

		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				cin >> A[i][j];
			}
		}

		// Bắt đầu duyệt đệ quy từ hàng 0 đến hết
		scan(0);

		cout << result << endl;
	}

	return 0;
}

SPOJ.COM - Thuật toán bài SDITSAVL - AVL Tree

admin@phamvanlam.com — Wed, 07 Jun 2017 18:05:00 GMT

Đề bài:

Bài toán này là bài toán mở rộng (với một chút thay đổi) từ bài toán: SDITSBST. Trong bài toán này, bạn được đưa cho 2 loại query:

1. Chèn một số nguyên x vào list
2. Cho số x.

Hãy tìm số k biểu diễn chỉ số của số x trong list nếu như list được sắp xếp theo thứ tự tăng dần. Chú ý rằng: bài toán này chỉ số bắt đầu tính từ 1.

Như tên bài toán đã gợi ý, chúng ta sẽ sử dụng cây nhị phân cân bằng, một trong những ví dụ của cây nhị phân cân bằng là cây AVL

Đầu vào

Dòng đầu tiên là số nguyên Q: biểu diễn số query. Q dòng tiếp theo sẽ biểu diễn 1 trong 2 loại query với định dạng như sau:

1 x: chèn số nguyên x vào list

2 x: tìm chỉ số k của số nguyên x nếu như list được sắp xếp theo thứ tự tăng dần

Đầu ra

Với mỗi query loại 2, in ra kết quả số nguyên k nếu như số nguyên x tồn tại trong list. Ngược lại in ra dòng "Data tidak ada".

Ví dụ

Input:

Output:

2 
Data tidak ada 
4 
1 
Data tidak ada

Giải thích

Cho đến query thứ 3, list bao gồm {74, 100}. Vì vậy, bạn phải in ra 2 - chỉ số của số 100 trong list. Đến query thứ 4, list vẫn không thay đổi, vì 70 không có trong list nên kết quả sẽ là "Data tidak ada".

Đến 3 query cuối cùng, list bao gồm {21, 33, 74, 100, 152}. Vì vậy, kết quả cho query thứ 8, 9, 10 lần lượt là 4, 1, "Data tidak ada".

Ràng buộc

1 ≤ Q ≤ 200000

1 ≤ x ≤ 10⁶

Đảm bảo rằng tất cả số nguyên chèn vào list là phân biệt.

Chú ý

Không đảm bảo rằng input sẽ là cây cân bằng. Bạn phải tự cân bằng cây.

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/SDITSAVL/

Phân tích

Bài này không có gì phải băn khoăn về cách giải, vì chúng ta sẽ dùng cây AVL. Vấn đề ở đây là cách cấu trúc mỗi node trong cây. Sau đây là cấu trúc mà mình đã làm:

struct Node {
  int x, height, numLeft, numRight;
  Node *left, *right;
};

Trong đó:

x: giá trị của số nguyên chèn vào
height: độ cao của node. Node lá sẽ có độ cao là 1. Độ cao của node cha là giá trị lớn nhất của độ cao hai node con.
numLeft: số node con, cháu,.. bên trái một node
numRight: số node con, cháu... bên phải một node

Lời giải

#include <iostream>
using namespace std;

int Q;
void insert(int x);
int  find(int x);
void init();

struct Node
{
	int x, height, numLeft, numRight;
	Node *left, *right;
};

Node *root;

int  height(Node *p);
void fixHeight(Node *p);
void fixNumLeft(Node *p);
void fixNumRight(Node *p);
int  balanceFactor(Node *p);

Node* initNode(int x);
Node* insert(Node *p, int x);
Node* findMin(Node *p);
Node* removeMin(Node *p);
Node* rotateLeft(Node *p);
Node* rotateRight(Node *p);
Node* balance(Node *p);
int   findOrder(Node *p, int x, int offset);

int main()
{
//	freopen("input.txt", "r", stdin);
	ios::sync_with_stdio(false);

	init();
	cin >> Q;
	for(int q = 0; q < Q; q++)
	{
		int type, x, k;
		cin >> type >> x;
		switch (type)
		{
		case 1:
			insert(x);
			break;
		case 2:
			k = find(x);
			if(k < 0) cout << "Data tidak ada" << endl;
			else cout << k << endl;
			break;
		default:
			cout << "There is something wrong" << endl;
			break;
		}
	}
}

void init()
{
	root = 0;
}

void insert(int x)
{
	root = insert(root, x);
}

int  find(int x)
{
	return findOrder(root, x, 0);
}

int height(Node *p)
{
	return p ? p->height : 0;
}

void fixHeight(Node *p)
{
	int hr = height(p->right);
	int hl = height(p->left);
	p->height = (hr > hl ? hr : hl) + 1;
}

void fixNumLeft(Node *p)
{
	if(p->left) p->numLeft = p->left->numLeft + p->left->numRight + 1;
	else p->numLeft = 0;
}

void fixNumRight(Node *p)
{
	if(p->right) p->numRight = p->right->numLeft + p->right->numRight + 1;
	else p->numRight = 0;
}

int balanceFactor(Node *p)
{
	return height(p->right) - height(p->left);
}

Node* initNode(int x)
{
	Node* newNode = new Node;
	newNode->x = x;
	newNode->height = 1;
	newNode->numLeft = 0;
	newNode->numRight = 0;
	newNode->left = 0;
	newNode->right = 0;
	return newNode;
}

Node* insert(Node *p, int x)
{
	if(!p)
		return initNode(x);

	if(x < p->x)
	{
		p->left = insert(p->left, x);
		fixNumLeft(p);
	}
	else if(x > p->x)
	{
		p->right = insert(p->right, x);
		fixNumRight(p);
	}
	return balance(p);
}

Node* findMin(Node *p)
{
	if(!p) return 0;
	if(p->left == 0) return p;
	return findMin(p->left);
}

Node* removeMin(Node *p)
{
	if(!p) return 0;
	if(p->left == 0) return p->right;
	p->left = removeMin(p->left);
	return balance(p);
}

Node* rotateLeft(Node *p)
{
	Node *q = p->right;
	p->right = q->left;
	q->left = p;
	fixHeight(p);
	fixHeight(q);
	fixNumRight(p);
	fixNumLeft(q);
	return balance(q);
}

Node* rotateRight(Node *p)
{
	Node *q = p->left;
	p->left = q->right;
	q->right = p;
	fixHeight(p);
	fixHeight(q);
	fixNumLeft(p);
	fixNumRight(q);
	return balance(q);
}

Node* balance(Node *p)
{
	fixHeight(p);
	fixNumLeft(p);
	fixNumRight(p);

	if(balanceFactor(p) == 2)
	{
		if(balanceFactor(p->right) < 0)
			p->right = rotateRight(p->right);
		return rotateLeft(p);
	}

	if(balanceFactor(p) == -2)
	{
		if(balanceFactor(p->left) > 0)
			p->left = rotateLeft(p->left);
		return rotateRight(p);
	}

	return p;
}

int findOrder(Node *p, int x, int offset)
{
	if(!p) return -1;
	if(p->x == x) return offset + p->numLeft + 1;

	if(p->x > x)
		return findOrder(p->left, x, offset);

	if(p->x < x)
		return findOrder(p->right, x, offset + p->numLeft + 1);
}

SPOJ.COM - Thuật toán bài HOTELS - Hotels Along the Croatian Coast

admin@phamvanlam.com — Wed, 07 Dec 2016 20:41:00 GMT

Đề bài:

Có N khách sạn dọc theo bờ biển Adriatic. Mỗi khách sạn sẽ có một giá tiền riêng. Sroljo đã trúng sổ xố được M tiền. Bây giờ anh ấy muốn mua một dãy những khách sạn liên tiếp. Sao cho tổng giá trị của chúng là lớn nhất. Nhưng chúng không được lớn hơn M.

Bạn hãy tính giá trị lớn nhất này.

Đầu vào

Dòng đầu tiên của đầu vào là 2 số N và M (1 ≤ N ≤ 300 000, 1 ≤ M < 2³¹). Dòng tiếp theo sẽ có N số nhỏ hơn 10⁶. Biểu diễn giá trị của những khách sạn trên.

Đầu ra

In ra kết quả cần tìm (biết kết quả lớn hơn 0)

Ví dụ 1:

Đầu vào:

5 12
2 1 3 4 5

Đầu ra:

Ví dụ 2:

Đầu vào:

4 9
7 3 5 6

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/HOTELS/

Phân tích

Mình sẽ sử dụng thuật toán tham lam Greedy, và thuật toán đó là thuật toán dịch cửa sổ Sliding Window. Mình sẽ duyệt từ đầu đến cuối. Mình sử dụng một biến trỏ vào đầu dãy, biến thứ 2 dùng để chạy từ 1 đến hết dãy. Biến thứ 2 sẽ tăng cho đến khi tổng của dãy số lớn hơn M thì dừng lại.

Lúc này mình được một giá trị là số lượng những khách sạn. Sau đó tăng con trỏ thứ nhất lên cho đến khi tổng của dãy nhỏ hơn M thì mình lại tiếp tục tăng biến thứ 2. Quá trình duyệt tiếp tục như vậy cho đến hết là mình sẽ tìm được kết quả.

Lời giải

Code C/C++

#include<stdio.h>

int main()
{
	int n = 0, m = 0;
	scanf("%d%d",&n,&m);

	int *a = new int[n];
	for(int i = 0; i < n; i++)
		scanf("%d",&a[i]);

	int st = 0;
	int i  = st;

	int sum = 0;
	int max = 0;

	while(i < n)
	{
		sum += a[i];

		if(sum > m)
		{
			sum -= a[i];
			if(sum > max) max = sum;

			sum += a[i];
			while(sum > m)
				sum -= a[st++];
		}
		i++;
	}

	if(sum > max) max = sum;
	printf("%d\n",max);

	delete[] a;

	return 0;
}

SPOJ.COM - Thuật toán bài IITKWPCO - Create Collections

admin@phamvanlam.com — Wed, 07 Dec 2016 20:26:00 GMT

Đề bài:

Little Feluda rất thích chơi. Như bạn biết, anh ấy chỉ thích chơi với những con số. Vì vậy anh ấy được đưa cho những số n. Bây giờ hãy nhóm những số đó thành nhóm gồm 2 số. Anh ấy có thể định dạng nhóm gồm 2 số nếu số nhỏ hơn bằng một nửa số lớn hơn.

Cho trước những số n. Hãy tìm ra số lượng nhóm tối đa thỏa mãn điều kiện trên.

Đầu vào

T: số lượng test case (1 <= T <= 100)

Mỗi test case:

Dòng đầu tiên chứa số n: (1 <= n <= 100)

Dòng tiếp theo chứa n số cách nhau bởi một dấu cách. Mỗi số sẽ thuộc từ 1 đến 10^6.

Đầu ra

Với mỗi test case, in ra trên một dòng kết quả tìm được.

Ví dụ

Đầu vào:

Đầu ra:

1
1

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/IITKWPCO/

Phân tích

Mình sẽ sử dụng thuật toán tham lam Greedy để giải. Thuật toán của mình là mình sẽ sử dụng mảng đếm để đếm tần suất xuất hiện của các số.
Sau đó, mình sẽ duyệt từ 0 đến số MAX (1000000). Mình sẽ kiểm tra nếu giá trị đếm tại i và 2*i là lớn hơn 0. Thì lúc này sẽ xuất hiện cặp đôi có dạng như đầu bài. Chỉ cần tìm ra giá trị đếm nào nhỏ hơn thì đó là số cặp đôi thỏa mãn tìm thấy. Sau đó, cập nhật lại mảng đếm và tiếp tục duyệt cho đến hết.
Xin mời bạn theo dõi cách triển khai của mình sau đây.

Lời giải

Code C/C++

#include<stdio.h>
const int MAX = 1000005;
int cnt[MAX];

int main()
{
	int T;
	scanf("%d",&T);
	for(int tc = 0; tc < T; tc++)
	{
		int n;
		scanf("%d",&n);

		for(int i = 0; i < MAX; i++)
			cnt[i] = 0;

		for(int i = 0; i < n; i++)
		{
			int t;
			scanf("%d",&t);
			cnt[t]++;
		}

		int max_collection = 0;
		for(int i = 0; i < MAX; i++)
		{
			if((cnt[i]==0) || (2*i >= MAX) || (cnt[2*i]==0)) continue;
			if(cnt[i] < cnt[2*i])
			{
				max_collection += cnt[i];
				cnt[2*i] -= cnt[i];
			}
			else
			{
				max_collection += cnt[2*i];
				cnt[2*i]= 0;
			}
		}
		printf("%d\n",max_collection);
	}
	return 0;
}

SPOJ.COM - Thuật toán bài GGD - Mr Toothless and His GCD Operatione

admin@phamvanlam.com — Mon, 05 Dec 2016 22:46:00 GMT

Đề bài:

Bạn được cho một số N và bạn phải tìm ra hai số a và b sao cho GCD(a, b) (ước chung lớn nhất của a và b) là lớn nhất có thể. Trong đó 1<=a<b<=N.

Đầu vào

Bắt đầu với số T (<= 100) - là số lượng test case. Mỗi test case sẽ bao gồm một số N duy nhất (2 ≤ N ≤ 10⁶).

Đầu ra

Với mỗi test case, in ra hai số a và b thỏa mãn. Nếu có nhiều test case thỏa mãn thì in ra cặp a và b thỏa mãn a + b là lớn nhất.

Ví dụ

Đầu vào:

1 2

Đầu ra:

Case 1: 1 2

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/GGD/

Problem Setter: Md Abdul Alim, Department of CSE, Bangladesh University of Business & Technology

Phân tích

Trước tiên mình áp dụng thuật toán tham lam Greedy để tìm ra chìa khóa của bài toán. Mình nhận ra rằng để ước chung lớn nhất của 2 số a và b là lớn nhất thì 2 số đó phải thỏa mãn là b = 2*a. Lúc này thực chất là mình phải tìm ra số a lớn nhất thỏa mãn b = 2*a.
Để làm được điều này một cách nhanh nhất mình sẽ áp dụng thuật toán chia để trị Divide and Conquer để giải quyết được nhanh hơn. Đối với việc áp dụng phương pháp chia để trị này thì việc đầu tiên phải xác định biên của kết quả. Rõ ràng giá trị của số a sẽ là từ 1 đến N. Việc tiếp theo chỉ là triển khai thuật toán chia để trị. Xin mời bạn theo dõi cách triển khải của mình ở dưới đây.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int N;					// Lưu số N đầu vào
int Num1, Num2;			// Lần lượt là 2 số được chọn

bool IsValid(int mid)
{
	int a = mid, b = mid*2;
	if(b <= N)
	{
		Num1 = a;
		Num2 = b;
		return true;
	}
	return false;
}

int main()
{
	// freopen("input.txt","r",stdin);
	int T;
	cin >> T;
	for(int tc = 0; tc < T; tc++)
	{
		cin >> N;
		if(N == 2) cout << "Case " << tc + 1 << ": 1 2" << endl;
		else if(N == 3) cout << "Case " << tc + 1 << ": 2 3" << endl;
		else
		{
			// Dùng phương pháp chia đôi để tìm ra giá trị lớn nhất của UCLN
			// UCLN sẽ nằm trong khoảng từ 1 đến N
			int Left = 1, Right = N, Mid = 0;
			while(Left < Right - 1)
			{
				Mid = (Left + Right) / 2;
				if(IsValid(Mid)) Left = Mid;
				else Right = Mid - 1;
			}
		if(IsValid(Right)) cout << "Case " << tc + 1 << ": " << Num1 << " " << Num2 << endl;
		else if(IsValid(Left)) cout << "Case " << tc + 1 << ": " << Num1 << " " << Num2 << endl;
		}
	}
	return 0;
}

SPOJ.COM - Thuật toán bài GCPC11J - Time to live

admin@phamvanlam.com — Mon, 05 Dec 2016 22:23:00 GMT

Đề bài:

Như bạn đã biết, hầu hết mạng máy tính được tổ chức dạng cây, tức là mỗi máy tính sẽ có thể kết nối với một và chỉ một máy tính khác. Có một khái niệm đó là Time to Live (TTL) được xác định là sau bao nhiêu bước một gói tin trong mạng bị mất nếu như nó không thể tới đúng đích. Mục đích của TTL là để tránh trường hợp gói tin lan truyền vòng tròn trong mạng dẫn đến lỗi.

Điểm đặt của bộ định tuyến (router) cái kết nối mạng với mạng khác là tối ưu khi mà giá trị lớn nhất cần có của TTL để gói tin được gửi từ router này sang bất kì router khác trong cùng một mạng là nhỏ nhất.

Cho trước thông tin của mạng. Bạn hãy tính giá trị lớn nhất cần phải có của TTL ở mạng này nếu như bạn có thể chọn một máy tính làm vai trò của router.

Đầu vào

Dòng đầu tiên của đầu vào bao gồm số c, với 1 ≤ c ≤ 100, là số lượng test case. Mỗi test case bắt đầu với một dòng chứa số N, là số lượng máy tính trong mạng 1 < N ≤ 10⁵. Máy tính được đánh số từ 0 đến N - 1. Sau đó là N - 1 dòng, xác định kết nối giữa 2 máy tính, gồm 2 số a và b. Có nghĩa là máy tính a kết nối với máy tính b và ngược lại, 0 ≤ a,b < N.

Đầu ra

Với mỗi test case, in ra một dòng chứa giá trị tối ưu nhất của TTL.

Ví dụ

Đầu vào:

Đầu ra:

1
1
2

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/GCPC11J/

Phân tích

Bài này thực chất là mình phải đi tìm khoảng cách lớn nhất của 2 điểm trên cây. Mình sẽ sử dụng 2 lần thuật toán tìm kiếm theo chiều rộng BFS để tìm ra khoảng cách này. Lần thứ nhất mình bắt đầu từ điểm bất kì và tìm ra điểm xa nhất so với điểm bắt đầu này. Sau khi tìm được điểm xa nhất trong lần thứ nhất, mình sẽ tiếp tục áp dụng BFS lần thứ 2 từ điểm vừa mới tìm được. Và mình lại tìm được điểm xa nhất so với điểm bắt đầu lần thứ 2. Lúc này mình tìm được khoảng cách xa nhất giữa 2 điểm trên cây. Giả sử là x.
Lúc này, nếu x chẵn thì giá trị TTL = x / 2. Còn nếu x lẻ thì TTL = x / 2 + 1.
Một điểm chú ý ở đây là số điểm N khá lớn. Do đó mình sẽ sử dụng danh sách liên kết để xác định liên kết giữa các điểm.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 100005;

typedef struct Node
{
	int id;
	Node *next;
}Node;

class List
{
public:
	Node *begin;
public:
	List()
	{
		begin = 0;
	}

	void Add(int id)
	{
		Node *tmp = new Node;
		tmp->id	  = id;
		tmp->next = begin;
		begin = tmp;
	}

	int GetLength()
	{
		int cnt = 0;
		Node *p = begin;
		while (p!=0)
		{
			cnt++;
			p = p->next;
		}
		return cnt;
	}
};

int N, Answer, IdMax;
List MyList[MAX];
int  Mark[MAX];

int queue[MAX];
int fr, re, leng;

void EnQueue(int id)
{
	queue[re] = id;
	re = (re + 1) % MAX;
	leng++;
}

int DeQueue()
{
	int p = queue[fr];
	fr = (fr + 1) % MAX;
	leng--;
	return p;
}

void BFS(int u)
{
	for(int i = 0; i < N; i++)
		Mark[i] = 0;
	fr = re = leng = 0;

	EnQueue(u);
	Mark[u] = 1;

	while(leng > 0)
	{
		int v = DeQueue();
		Node *p = MyList[v].begin;

		while(p != 0)
		{
			int k = p->id;
			if(!Mark[k])
			{
				Mark[k] = Mark[v] + 1;
				if(Mark[k] > Answer)
				{
					IdMax = k;
					Answer = Mark[k];
				}
				EnQueue(k);
			}
			p = p->next;
		}
	}
}

int main()
{
	ios::sync_with_stdio(false);
//	freopen("input.txt","r",stdin);

	int T;
	cin >> T;

	for(int tc = 0; tc < T; tc++)
	{
		IdMax = Answer = 0;
		cin >> N;
		for(int i = 0; i < N; i++)
			MyList[i].begin = 0;

		int a,b;
		for(int i = 0; i < N-1; i++)
		{
			cin >> a >> b;
			MyList[a].Add(b);
			MyList[b].Add(a);
		}

		BFS(1);
		BFS(IdMax);
		Answer--;

		if(Answer%2==0) Answer /= 2;
		else Answer = Answer / 2 + 1;

		cout << Answer << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài VMSUBSTR - Vườn cây của ba

admin@phamvanlam.com — Mon, 05 Dec 2016 20:58:00 GMT

Đề bài:

Sau một năm học cày cuốc vất vả; Hè này Huy quyết định mời bạn về quê chơi. Huy sẽ dẫn bạn đi leo núi, ngắm cảnh... và sẽ mở một buổi chiêu đãi bạn tài nhà mình. "Nhà rộng và đẹp lắm, có cả một vườn cây ăn trái sum xuê !" - Huy giới thiệu về ngôi nhà của mình.

Sau khi kì kèo với ba, Huy đã xin được hái trái trong vườn đãi bạn. Nhưng với một điều kiện: Huy chỉ được hái trái những LOẠI cây mà ba qui định. Vườn cây chia thành L khu đất liên tiếp nằm thẳng hàng (được đánh số thứ tự từ 1 đến L từ đầu vườn đến cuối vườn), mỗi khu chỉ trồng duy nhất một cây. Nhà Huy có rất nhiều nhân công, mỗi nhân công sẽ chấp nhận làm việc trên những khu đất liên tiếp.

Vì muốn đãi bạn thật nhiều trái cây, nên Huy sẽ tận dụng hái hết TẤT CẢ những cây được ba cho phép. Nhưng mắc nỗi phải dẫn bạn đi chơi ròi, nên không có thời gian hái trái cây. Nên Huy sẽ nhờ đến các nhân công.

Bạn tính xem Huy sẽ phân công ít nhất bao nhiêu nhân công để thực hiện kế hoạch chiêu đãi trái cây của mình? Biết rằng mỗi nhân công sẽ hái hết tất cả trái cây ở các khu đất mình được phân vào.

Đầu vào

Dòng 1: Gồm 1 số nguyên dương duy nhất: L - số khu đất trong khu vườn.

Dòng 2: Chứa xâu S gồm đúng L chữ cái Latin (in thường hoặc hoa), miêu tả khu vườn của Huy. Mỗi chữ cái cho biết loại cây được trồng ở khu đất tương ứng

Dòng 3: Q - số trường hợp mà bạn phải xứ lý.

Q dòng tiếp, mỗi dòng mô tả một trường hợp và gồm các chữ cái Latin (in thường hoặc hoa). Mỗi chữ đại diện cho một loại cây được phép sử dụng.

Đầu ra

Với mỗi trường hợp, ghi ra 1 dòng duy nhất là số nhân công ít nhất cần nhờ đến.

Giới hạn:

L ≤ 1,000,000;

Q ≤ 100,000;

Số ký tự trong mỗi query không quá 52.

Trong mỗi query, các ký tự không lặp lại Trong 50% số test, L ≤ 1000, Q ≤ 1000;

Ví dụ

Đầu vào:

7
abacaba
3
ac
b
ab

Đầu ra:

3
2
2

Giải thích:

Với trường hợp 'ac', Huy chỉ hái những cây loại 'a' và 'c'. Nên Huy cần nhờ ít nhất 3 nhân công lo 3 phần 'a', 'aca', 'a';
Với trường hợp 'b', Huy cần nhờ ít nhất 2 nhân công lo 2 phần 'b';
Với trường hợp 'ab', Huy cần nhờ ít nhất 2 nhân công lo 2 phần 'aba';

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://vn.spoj.com/problems/VMSUBSTR/

Phân tích

Mình sẽ sử dụng thuật toán tham lam Greedy để giải quyết bài toán.
Trước tiên, mình sẽ dùng một mảng đếm, mục đích là để đánh dấu xem trong các loại quả thì quả nào được phép hái. Sau khi đã có mảng đánh dấu rồi thì mình sẽ duyệt mảng, để tìm ra các cụm mà chỉ có những phần tử thuộc tập cho phép liền nhau. Đó chính là kết quả
Xin mời bạn theo dõi cách triển khai của mình sau đây.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX = 1000005;
const int MAX_QUERY = 55;

int  L;                 // Số khu đất trong vườn
char S[MAX];            // Xâu đầu vào
int	 Q;                 // Số testcase
char Query[MAX_QUERY];  // Xâu querry
int  MinHuman;          // Số nhân công tối đa.
int  Count[150];        // Kiểm tra chữ cái có xuất hiện trong querry hay không.

int main()
{
	//freopen("input.txt","r",stdin);
	ios::sync_with_stdio(false);
	cin >> L >> S >> Q;
	for(int i = 0; i < Q; i++)
	{
		for(int i = 0; i < 150; i++)
			Count[i] = 0;

		// Nhập đầu vào
		MinHuman = 0;
		cin >> Query;

		// Đánh dấu các kí tự xuất hiện trong xâu query
		int Leng = 0;
		while(Query[Leng] != '\0')
		{
			Count[Query[Leng]] = 1;
			Leng++;
		}

		// Duyệt từ đầu đến cuối mảng
		// Tìm ra số cụm chỉ toàn các kí tự thuộc query.
		int before = 0;
		for(int i = 0; i < L; i++)
		{
			if(Count[S[i]] == 1 && before == 0)
			{
				MinHuman++;
				before = 1;
			}
			else if(Count[S[i]] == 0 && before == 1)
			{
				before = 0;
			}
		}
		// In kết quả
		cout << MinHuman << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài HERDING - Herding

admin@phamvanlam.com — Mon, 05 Dec 2016 20:40:00 GMT

Đề bài:

Có một lượng mèo bị lạc trong thành phố. Và bạn được giao nhiệm vụ để tìm lại được hết số mèo. Đây là cơ hội lý tưởng cho bạn để kiểm nghiệm phát minh mới nhất của bạn. Một cái bẫy mèo đảm bảo sẽ bắt được những chú mèo khi nó đi vào khu vực của thành phố.

May mắn thay, bạn được trợ giúp bởi một trong những nhà tâm lý học hàng đầu về mèo - người có khả năng kì diệu về tài tiên đoán. Cho trước một vùng hình vuông trong thành phố, và chính xác 4 hướng con mèo sẽ đi (đông, tây, nam, bắc). Trong khi những thông tin này là trong tầm tay, bạn vẫn không thể biết được những nơi mà hiện tại con mèo đang ở.

Để chứng minh tính hiệu quả về giá của phương pháp này, và dĩ nhiên là tối thiểu hoá những cái bẫy sẽ được sử dụng.

Đầu vào

Bắt đầu là một dòng gồm 2 số n và m, cách nhau bởi dấu cách,1 ≤ n, m ≤ 1000. Khu vực sẽ có kích thước nxm. n dòng tiếp theo, mỗi dòng có m kí tự, gồm 4 loại 'N', 'E', 'S', và 'W' biểu diễn hướng Bắc, Đông, Nam, Tây. Kí tự đầu tiên của dòng đầu tiên sẽ là điểm trên cùng bên trái. Hướng trên mỗi ô vuông sẽ là hướng con mèo sẽ đi, nếu con mèo ở ô đó. Đảm bảo rằng con mèo sẽ không ra khỏi thành phố.

Đầu ra

In ra số lượng bẫy tối thiểu.

Ví dụ

Đầu vào:

3 4
SWWW
SEWN
EEEN

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/HERDING/

Phân tích

Mình nhận thấy rằng là khi con mèo đi vào thành phố, cách nó đi chính là hướng được ghi tại ô vuông nó đang đứng. Tức là hướng đã xác định trước. Do đó, để tìm được số lượng bẫy tối thiểu thì mình phải đặt bẫy làm sao mà nó ở đúng vị trí mà chắc chắn con mèo sẽ phải đi qua đó.
Do đó, mình sẽ sử dụng thuật toán tìm kiếm theo chiều sâu DFS để xác định các đường đi đó. Mỗi đường đi mình chỉ cần đặt một cái bẫy là đủ để có thể bắt được hết số mèo.
Xin mời bạn theo dõi code của mình phía dưới đây và cùng tìm hiểu xem thế nào nhé.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX = 1005;
const int W   = 0;
const int N   = 1;
const int E   = 2;
const int S   = 3;

int n, m, cnt;
int Matrix[MAX][MAX], Mark[MAX][MAX];

int drow[] = { 0,-1,0, 1};
int dcol[] = {-1, 0,1, 0};

bool Check(int dir, int r, int c)
{
	if(dir == W && Matrix[r][c] == E) return true;
	if(dir == E && Matrix[r][c] == W) return true;
	if(dir == S && Matrix[r][c] == N) return true;
	if(dir == N && Matrix[r][c] == S) return true;
	return false;
}

void DFS(int row, int col)
{
	for(int i = 0; i < 4; i++)
	{
		int r = row + drow[i];
		int c = col + dcol[i];
		if(r >= 0 && r < n && c >= 0 && c < m && Mark[r][c] == 0
		&& (i == Matrix[row][col] || Check(i, r, c)))
		{
			Mark[r][c] = 1;
			DFS(r,c);
		}
	}
}

int main()
{
	ios::sync_with_stdio(false);
//	freopen("input.txt","r",stdin);
	cnt = 0;
	cin >> n >> m;
	for(int i = 0; i < n; i++)
	{
		char temp[MAX];
		cin >> temp;
		for(int j = 0; j < m; j++)
		{
			if(temp[j] == 'W') Matrix[i][j] = W;
			else if(temp[j] == 'N') Matrix[i][j] = N;
			else if(temp[j] == 'E') Matrix[i][j] = E;
			else if(temp[j] == 'S') Matrix[i][j] = S;
			Mark[i][j] = 0;
		}
	}
	for(int i = 0; i < n; i++)
		for(int j = 0; j < m; j++)
		{
			if(Mark[i][j] == 0)
			{
				Mark[i][j] = 1;
				DFS(i,j);
				cnt++;
			}
		}
	cout << cnt << endl;
	return 0;
}

SPOJ.COM - Thuật toán bài HANGOVER - Hangover

admin@phamvanlam.com — Mon, 05 Dec 2016 19:48:00 GMT

Đề bài:

Bạn có thể tạo ra độ dài bao xa khi xếp những quân bài bên trên một cái bàn. Nếu bạn có một quân bài bạn có thể tạo ra độ dài tối đa là 1/2 quân bài. Giả sử rằng những quân bài vuông góc với bàn. Với 2 quân bài bạn có thể làm cho quân bài trên nhô ra so với quân bài ở dưới độ dài là 1/2 quân bài. Và quân bài dưới cùng nhô ra so với bàn 1/3 độ dài quân bài. Như vậy, tổng độ dài là 1/2 + 1/3 = 5/6 độ dài quân bài. Như vậy, bạn có thể xếp được n quân bài với độ dài nhô ra là: 1/2 + 1/3 + 1/4 + ... + 1/(n+1)) độ dài quân bài.

Đầu vào

Bao gồm một hay nhiều test case, mỗi test case chỉ bao gồm 1 dòng, chứa 1 số thực dương c, có giá trị từ 0.01 đến 5.20. c có chính xác 3 chữ số.

Đầu ra

Mỗi test case in ra trên một dòng số lượng quân bài tối thiểu để đạt được c độ dài quân bài. Đầu ra theo dạng ví dụ dưới đây.

Ví dụ

Đầu vào:

1.00
3.71
0.04
5.19
0.00

Đầu ra:

3 card(s)
61 card(s)
1 card(s)
273 card(s)

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/HANGOVER/

Phân tích

Với bài toán này, cách xếp con bài là không thay đổi. Do đó, mình sẽ sử dụng một mảng để lưu lại độ dài khi xếp n con bài. Thuật toán ở đây sẽ là thuật toán vét cạn Brute Force.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 1000000;
float a[MAX];	// Độ dài khi xếp n quân bài

float F(int n)
{
	float f = 0.0f;
	for(int i = 2; i <= n+1; i++)
		f += 1.0f/i;
	return f;
}

int main()
{
	//freopen("input.txt","r",stdin);
	ios::sync_with_stdio(false);
	for(int i = 0; i < MAX; i++)
		a[i] = -1;

	float c = 0.0f;
	while(true)
	{
		cin >> c;
		if(c == 0.00) break;
		for(int i = 0; i < MAX; i++)
		{
			float f = 0.0f;
			if(a[i] < 0)
			{
				f = F(i);
				a[i] = f;
			}
			else f = a[i];

			if(f > c)
			{
				cout << i << " card(s)" << endl;
				break;
			}
		}
	}
	return 0;
}

SPOJ.COM - Thuật toán bài GIRLSNBS - Girls and Boys

admin@phamvanlam.com — Mon, 05 Dec 2016 05:12:00 GMT

Đề bài:

Có G học sinh nữ và B học sinh nam trong một lớp để tốt nghiệp. Bạn cần phải sắp xếp họ theo một hàng duy nhất cho buổi lễ tốt nghiệp. Để gây ấn tượng hơn về sự đa dạng, bạn muốn tránh có quá nhiều học sinh nam hay quá nhiều học sinh nữ ngồi liên tiếp. Bạn quyết định sắp xếp để giảm thiểu sự đều đặn về giới tính. Sự đều đặn về giới tính ở đây là số lượng học sinh có cùng giới tính xuất hiện liên tiếp.

Cho trước G và B, hãy tính giá trị nhỏ nhất của sự đều đặn về giới tính trong tất cả các trường hợp có thể sắp xếp.

Đầu vào

Mỗi test case sẽ cho trên một dòng. Mỗi dòng bao gồm 2 số nguyên G và B biểu diễn số lượng con gái và con trai trong một lớp. Trong đó, 0 ≤ G, B ≤ 1000. Và kết thúc của đầu vào là 2 số -1.

Đầu ra

Với mỗi test case, in ra một dòng với một số nguyên duy nhất biểu diễn giá trị cần tìm.

Ví dụ

Đầu vào:

Đầu ra:

1
3
1000

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/GIRLSNBS/

Phân tích

Rõ ràng bài này mình sẽ áp dụng thuật toán tham lam Greedy để giải. Có lẽ bạn cũng nhận ra rằng để giảm thiểu sự đều đặn về giới tính thì ta phải sắp xếp các học sinh theo cách so le con trai và con gái ra một cách đều đặn.
Ví dụ như mình có 6 con trai (B) và 2 con gái (G): khi đó cách sắp xếp tối ưu là: B B G B B G B B => Kết quả là 2
Tiếp theo, nếu như mình có 7 con trai và 2 con gái thì sao. Khi đó kết quả tối ưu là: B B G B B G B B B => Kết quả là 3.
Đọc đến đây có lẽ bạn đã phát hiện ra quy luật rồi phải không. Xin mời bạn theo dõi code của mình dưới đây để hiểu rõ hơn nhé.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

int main()
{
//	freopen("input.txt","r",stdin);
	int G, B;
	while(true)
	{
		cin >> G >> B;
		if(G == -1 && B == -1) break;

		int min = ((G < B) ? G : B);
		int max = (G + B) - min;

		int tmp = max % (min+1);
		if(tmp == 0) cout << max / (min+1) << endl;
		else cout << (max / (min+1)) + 1 << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài GCPC11F - Diary

admin@phamvanlam.com — Sun, 04 Dec 2016 17:31:00 GMT

Đề bài:

Ngày nay, con người muốn kết nối với nhau theo một cách an toàn hơn nhờ việc sử dụng thuật toán mã hóa không đối xứng, ví dụ RSA. Tuy nhiên, anh trai mình lại sử dụng một cái khác, một phương pháp mã hóa đơn giản hơn, để viết nội dung nhật kí của anh ấy. Khoảng cách giữa kí tự gốc và kí tự được mã hóa là cố định. Nếu chúng ta định nghĩa khoảng cách này là d = 5, thì khi đó A sẽ được thay bởi F; B được thay bởi G; C được thay bởi H;... và Z được thay bởi E.

Với việc biết trước khoảng cách d này, việc giải mã sẽ trở nên vô cùng đơn giản. Tuy nhiên anh trai mình lại sử dụng khoảng cách này một cách ngẫu nhiên. Để giải mã mình phải đoán khoảng cách này. Vì vậy, mình sử dụng một dấu hiệu đó là kí tự E xuất hiện nhiều hơn các kí tự khác. Bạn có thể viết một chương trình để tính khoảng cách d dựa vào vấn đề đó là kí tự được sử dụng nhiều nhất trong chuỗi kí tự đã được mã hóa sẽ được thay thế cho kí tự E. Và dĩ nhiên là giải mã chuỗi kí tự đó.

Đầu vào

Bao gồm nhiều test case, số test case c thỏa mãn 1 ≤ c ≤ 100. Mỗi test case được cho trên 1 dòng. Nội dung chỉ bao gồm các kí tự viết hoa từ A-Z, và có tối đa 1000 kí tự, bao gồm cả dấu cách.

Đầu ra

In ra một dòng chứa khoảng cách d nhỏ nhất có thể (0 ≤ d ≤ 25) và chuỗi kí tự được giải mã. Nếu không thể giải mã được do có nhiều khoảng cách thỏa mãn luật trên thì in ra "NOT POSSIBLE". Chú ý rằng kí tự cách sẽ không được mã hóa.

Ví dụ

Đầu vào:

4
RD TQIJW GWTYMJWX INFWD JSYWNJX ZXJ F XNRUQJ JSHWDUYNTS YJHMSNVZJ
THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
XVIDRE TFCCVXZRKV GIFXIRDDZEX TFEKVJK UVTIPGKZFE
XVIDRE TFCCVXZRKV GIFXIRDDZEX TFEKVJK

Đầu ra:

5 MY OLDER BROTHERS DIARY ENTRIES USE A SIMPLE ENCRYPTION TECHNIQUE
10 JXU GKYSA RHEMD VEN ZKCFI ELUH JXU BQPO TEW
17 GERMAN COLLEGIATE PROGRAMMING CONTEST DECRYPTION
NOT POSSIBLE

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/GCPC11F/

Phân tích

Mình sẽ sử dụng thuật toán tham lam Greedy để giải quyết bài toán này.
Để giải bài toán này, trước tiên mình phải tìm ra kí tự nào được sử dụng nhiều nhất để tính ra khoảng cách d theo như luật trên. Có nhiều cách để tính, còn ở đây mình sử dụng cách đơn giản nhất đó là sử dụng mảng đếm tần suất.
Việc tiếp theo là mình sẽ đếm xem có bao nhiêu trường hợp có cùng khoảng cách d như vậy. Nếu như có hơn một trường hợp thì không thể giải mã được. + Nếu có thể giải mã được thì mình sẽ bắt đầu giải mã.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX = 1005;
int cnt[300];

int main()
{
	//freopen("input.txt","r",stdin);
	ios::sync_with_stdio(false);

	int Testcase = 0;
	cin >> Testcase;

	cin.get();
	for(int tc = 0; tc < Testcase; tc++)
	{
		for(int i = 0; i < 300; i++)
			cnt[i] = 0;

		char text[MAX];
		cin.getline(text,MAX);

		int leng = 0;
		while(text[leng] != '\0')
		{
			cnt[text[leng]]++;
			leng++;
		}

		int max_frequent = 0;	// tần suất nhiều nhất
		int character = 0;		// kí tự với tần suất lớn nhất
		for(int i = 'A'; i <= 'Z'; i++)
			if(cnt[i] > max_frequent)
			{
				max_frequent = cnt[i];
				character = i;
			}

		// Đếm số kí tự có tần suât lớn nhất
		int num_max = 0;
		for(int i = 'A'; i <= 'Z'; i++)
			if(cnt[i] == max_frequent)
				num_max++;

		// Nếu có nhiều hơn một trường hợp thì không thể giải mã
		if(num_max > 1)
			cout << "NOT POSSIBLE" << endl;
		else	// giải mã
		{
			int d;
			if(character >= 'E')
			{
				d = character - 'E';
				cout << d << " ";

				for(int i = 0; i < leng; i++)
				{
					if(text[i] == ' ') cout << ' ';
					else
					{
						int temp = text[i] - d;
						if(temp >= 'A') cout << (char)temp;
						else
						{
							int delta = 'A' - temp;
							cout << (char)('Z' - delta + 1);
						}
					}
				}
			}
			else
			{
				d = ('Z' - 'E') + character - 'A' + 1;
				cout << d << " ";

				int back = 'E' - character;
				for(int i = 0; i < leng; i++)
				{
					if(text[i] == ' ') cout << ' ';
					else
					{
						int temp = text[i] + back;
						if(temp <= 'Z') cout << (char) temp;
						else
						{
							int del = temp - 'Z';
							cout << (char)('A' + del - 1);
						}
					}
				}
			}
			cout << endl;
		}
	}

	return 0;
}

SPOJ.COM - Thuật toán bài FINDSR - Find String Roots

admin@phamvanlam.com — Sun, 04 Dec 2016 17:02:00 GMT

Đề bài:

Trong toán học, căn bậc N của M là một số K thỏa mãn K^N = M hay KKK...K = M, trong đó có N số K nhân với nhau. Chúng ta có thể chuyển đổi chúng sang áp dụng với xâu. Trong bài toán này, chúng ta sẽ sử dụng ghép xâu thay vì phép nhân. Do đó, căn bậc N của xâu S là một xâu T thỏa mãn T^N = S, trong đó T^N = T.T.T.T...T là N xâu T ghép với nhau. Ví dụ nếu xâu S là "abcabcabcabc", với N = 2 thì xâu T = "abcabc" là căn bậc N của S. Và nếu N = 4 thì xâu T = "abc". Chú ý rằng nếu N = 1 thì căn bậc N của S là chính nó.

Cho trước một xâu S và bạn phải tìm ra số N lớn nhất mà căn bậc N của S tồn tại. Trong ví dụ trên đáp án là N = 4, bởi vì không có số nguyên N nào lớn hơn 4 mà tồn tại căn bặc N của S.

Đầu vào

Đầu vào bao gồm nhiều test case, mỗi cái được cho trên một dòng. Mỗi dòng không tồn tại xâu rỗng và có tối đa 10⁵kí tự, và chỉ bao gồm chữ số và chữ cái thường. Dòng cuối cùng chứa một kí tự '*' (không bao gồm '').

Đầu ra

Với mỗi test case, in ra số nguyên duy nhất là kết quả.

Ví dụ

Đầu vào:

abcabcabcabc
abcdefgh012
aaaaaaaaaa
*

Đầu ra:

4
1
10

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/FINDSR/

Phân tích

Ở đây yêu cầu là tìm ra số N lớn nhất mà tồn tại căn bậc N của S, nghĩa là độ dài mỗi xâu T phải là nhỏ nhất. Do đó, mình sẽ xét độ dài của T từ 1 rồi tăng dần lên. Khi nào thỏa mãn thì mình sẽ dừng lại và đó chính là kết quả cần tìm.
Sau đây, mời bạn theo dõi cách triển khai code sử dụng thuật toán tham lam Greedy của mình.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 1000000;

/**
* Tính độ dài xâu str
*/
int GetLength(char *str)
{
	int length = 0;
	while(str[length] != '\0') length++;
	return length;
}

int main()
{
	//freopen("input.txt","r",stdin);
	ios::sync_with_stdio(false);

	char str[MAX];
	while(true)
	{
		cin >> str;
		int length = GetLength(str);
		if(length == 1 && str[0] == '*') break;

		int len_sub = 1;	// Độ dài xâu con T
		int N = 0;
		while(true)
		{
			// Duyệt từng độ dài của len_sub và tăng dần lên
			if(length % len_sub != 0)
			{
				len_sub++;
				continue;
			}

			// Kiểm tra xem với độ dài len_sub như vậy có thỏa mãn hay không
			int id = 0;
			bool check = true;
			while(true)
			{
				if(id + len_sub + 1> length) break;
				for(int i = 0; i < len_sub; i++)
				{
					if(str[i+id] != str[i+len_sub+id])
					{
						check = false;
						break;
					}
				}
				if(check == false) break;
				id += len_sub;
			}

			if(check == true)
			{
				N = length / len_sub;
				break;
			}
			len_sub++;
		}
		cout << N << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài FCTRL - Factorial

admin@phamvanlam.com — Sun, 04 Dec 2016 16:36:00 GMT

Đề bài:

Thành phần quan trọng nhất của mạng GSM là Base Transceiver Station (BTS). Những thiết bị này xác định một vùng gọi là cells và mỗi điện thoại kết nối với BTS với cường độ tín hiệu mạnh nhất. Dĩ nhiên những BTS này cần được chú ý và những nhà chuyên môn cần kiểm tra chúng định kì.

Những chuyên gia ACM gần đây đã đối mặt với một vấn đề thú vị. Cho trước một tập những BTS cần thăm, họ cần phải tìm ra đường đi ngắn nhất để thăm tất cả những điểm đó và quay về điểm trung tâm. Những lập trình viên đã dành vài tháng để nghiên cứu về vấn đề này và chưa có kết quả. Họ không thể tìm ra giải pháp nào đủ nhanh. Sau một thời gian dài, một lập trình viên đã tìm ra vấn đề này ở một hội nghị. Không may anh ta nhận ra rằng vấn đề này được gọi là "Travelling Salesman Problem" và nó khó để giải quyết. Nếu chúng ta có N BTS để thăm, chúng ta có thể thăm chúng theo thứ tự ngẫu nhiên, cho kết quả là N!. Cái này được gọi là giai thừa và có thể được tính là tích 123*4...N. Kết quả có thể là rất cao dù cho số N là tương đối nhỏ.

Các lập trình viên hiểu rằng không có cơ hội nào để giải quyết bài toán này. Nhưng bởi vì họ đã nhận được trợ cấp nghiên cứu của chính phủ, do đó họ phải tiếp tục nghiên cứu và đưa ra ít nhất một vài kết quả. Vì vậy họ đã bắt đầu nghiên cứu cách thức hoạt động của hàm tính giai thừa.

Ví dụ, họ định nghĩa một hàm Z. Với bất kì số nguyên dương N nào, Z(N) là những số 0 ở cuối của kết quả dạng thập phân của N!. Họ nhận ra rằng kết quả này sẽ không giảm . Nếu có 2 số N₁<N₂, thì Z(N₁) <= Z(N₂). Nó là bởi vì họ sẽ không thể làm mất đi những số 0 bởi việc nhân với bất kì số nguyên dương nào. Chúng ta chỉ có thể có thêm một hoặc nhiều số 0 mới. Hàm Z khá là thú vị, vì vậy chúng ta cần có một chương trình để tính nó một cách hiệu quả nhất.

Đầu vào

Bắt đầu bằng số nguyên T, T <= 10000, là số lượng test case. Sau đó là T số nguyên theo sau, mỗi số ở một dòng, có giá trị từ 1 đến 1000000000.

Đầu ra

Với mỗi test case, in ra kết quả là một số nguyên không âm, là kết quả của Z(N).

Ví dụ

Đầu vào:

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/FCTRL/

Phân tích

Bài này đầu vào cho số N tối đa là 1000000000. Do đó mình không thể tính toán trực tiếp được. Bài này mình sẽ sử dụng thuật toán tham lam greedy để giải quyết.
Mình nhận ra rằng là 5 * 2 = 10. Nghĩa là số N tăng lên 5 đơn vị thì mình sẽ có thêm một số 0.
```
5! = 120 => Z(5) = 1 
10! = 3628800 => Z(10) = 2 
15! = 1307674368000 => Z(15) = 3 ...
```
Từ đó mình triển khai được thuật toán tham lam như sau đây. Mời bạn theo dõi.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

typedef unsigned long long ull;

int main()
{
	//freopen("input.txt","r",stdin);
	ios::sync_with_stdio(false);

	int Testcase, n;
	cin >> Testcase;
	for(int tc = 0; tc < Testcase; tc++)
	{
		cin >> n;
		ull count5 = 0, temp = 5;

		while(true)
		{
			ull t = n / temp;
			if(t == 0) break;

			count5 += t;
			temp *= 5;
		}
		cout << count5 << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài FASHION - Fashion Shows

admin@phamvanlam.com — Sat, 03 Dec 2016 20:33:00 GMT

Đề bài:

Một cuộc thi biểu diễn thời trang đánh giá những người tham gia dựa vào độ hot của họ. Có hai chương trình khác nhau được tổ chức, một cho đàn ông và một cho đàn bà. Thời gian của chương trình thứ 3 vẫn chưa được quyết định.

Bây giờ kết quả của hai chương trình trước đã được công bố. Những người tham gia của hai chương trình đã hẹn nhau, tuy nhiên họ khó khăn trong việc tìm ra đối tác của mình. Maximum Match dating serive (MMDS) đã giúp họ bằng cách kết nối họ sao cho tối đa hóa được độ hot của họ.

Nếu một người đàn ông được đánh giá độ hot là x, và người phụ nữ là y thì giá trị của họ sẽ là x*y. Cả hai chương trình, mỗi cái bao gồm N ứng viên. MMDS đã làm xong công việc của họ. Công việc của bạn là tìm ra tổng độ hot của họ.

Đầu vào

Dòng đầu tiên là số lượng test case t. Sau đó là các test case. Mỗi cái bao gồm 3 dòng. Dòng đầu tiên là số nguyên N, 1 <= N <= 1000. Dòng thứ 2 chứa N số nguyên biểu diễn mức điểm của những người đàn ông. Dòng thứ 3 gồm N số nguyên biểu diễn mức điểm của những người phụ nữ. Tất cả độ hot có giá trị từ 0 đến 10.

Đầu ra

Với mỗi test case, in ra một số nguyên là tổng độ hot của họ theo cách của MMDS đã làm.

Ví dụ

Đầu vào:

Đầu ra:

5
15

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/FASHION/

Phân tích

Bài toán này mình nhận ra rằng, để kết quả lớn nhất thì ta phải nhân các giá trị lớn nhất với nhau. Từ đó suy ra mình sẽ phải sắp xếp lại dãy điểm của đàn ông và phụ nữ.
Có nhiều cách sắp xếp tuy nhiên cách nhanh và đơn giản nhất là sử dụng Counting Sort (sử dụng mảng đếm tần suất). Bởi lẽ độ hot chỉ có giá trị từ 0 đến 10.
Sau đây mời bạn theo dõi cách mình triển khai thuật toán tham lam Greedy của mình để giải bài toán này.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int main()
{
	//freopen("input.txt","r",stdin);
	int Testcase = 0;
	cin >> Testcase;
	for(int tc = 0; tc < Testcase; tc++)
	{
		int n = 0;
		cin >> n;

		// Mảng đếm số lượng người có lượng hot i của của nam và nữ
		int cnt_men[11], cnt_wen[11];
		for(int i = 0; i < 11; i++)
		{
			cnt_men[i] = 0;
			cnt_wen[i] = 0;
		}

		// Nhập đầu vào và đếm số người ứng với độ hot đã cho
		// nam
		for(int i = 0; i < n; i++)
		{
			int temp = 0;
			cin >> temp;
			cnt_men[temp]++;
		}
		// nữ
		for(int i = 0; i < n; i++)
		{
			int temp = 0;
			cin >> temp;
			cnt_wen[temp]++;
		}

		// Sắp xếp độ hot cho n người nam dùng counting sort
		int *men = new int[n];
		int id_men = 0;
		for(int i = 0; i <= 10; i++)
			for(int j = 0; j < cnt_men[i]; j++)
				men[id_men++] = i;

		// Sắp xếp độ hot cho n người nữ dùng counting sort
		int *wen = new int[n];
		int id_wen = 0;
		for(int i = 0; i <= 10; i++)
			for(int j = 0; j < cnt_wen[i]; j++)
				wen[id_wen++] = i;

		// Tính độ hot tổng
		int sum = 0;
		for(int i = 0; i < n; i++)
			sum += men[i] * wen[i];

		cout << sum << endl;
		delete[] wen;
		delete[] men;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài FACEFRND - Friends of Friends

admin@phamvanlam.com — Sat, 03 Dec 2016 20:10:00 GMT

Đề bài:

Bob dùng trang mạng xã hội hầu hết thời gian. Anh ấy đã tò mò về vấn đề bạn của bạn trên trang mạng xã hội này. Nếu như X là bạn anh ấy. Và Y là bạn của X. Mà Y không phải bạn của anh ấy. Khi đó Y được gọi là bạn của bạn. Bạn phải tìm ra xem Bob có bao nhiêu bạn của bạn. Biết các ID được dùng trên mạng xã hội là số duy nhất bao gồm 4 chữ số.

Đầu vào

Dòng đầu tiên là số nguyên N, 1 <= N <= 100 - là số bạn trên trang mạng xã hội của Bob. Sau đó là N dòng. Số đầu tiên của mỗi dòng là ID của bạn Bob và sau đó là số M (1 <= M <= 100) là số bạn của anh ta. Sau đó là M số nguyên là ID của những người bạn (không bao gồm Bob).

Đầu ra

In ra một số nguyên xác định số bạn của bạn của Bob.

Ví dụ

Đầu vào:

3
2334 5 1256 4323 7687 3244 5678
1256 2 2334 7687
4323 5 2334 5678 6547 9766 9543

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/FACEFRND/

Phân tích

Bài toán có vẻ khá rõ ràng. Ở đây mình sử dụng thuật toán tham lam Greedy để giải bài toán. Mình sẽ thực hiện đúng như trong đề bài. Đó là tìm ra những người là bạn của bạn Bob.
Vì ID là một số duy nhất có 4 chữ số nên mình sử dụng mảng đánh dấu gồm 10000 phần tử để đánh dấu trạng thái của các ID là bạn của Bob hay không, và đã xuất hiện chưa.
Mời bạn theo dõi code sau để hiểu rõ hơn về cách triển khai của mình.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX = 10005;

bool exist[MAX];        // Đánh dấu xem tồn tại hay chưa
bool friend_bob[MAX];   // có phải bạn của Bob không

int main()
{
	// Khởi tạo giá trị là false
	for(int i = 0; i < MAX; i++)
	{
		exist[i] = false;
		friend_bob[i] = false;
	}

	// đếm số lượng bạn của bạn
	int cnt_fof = 0;

	int n = 0;
	cin >> n;
	for(int i = 0; i < n; i++)
	{
		int id_fob = 0;
		cin >> id_fob;

		if(exist[id_fob])
		{
			cnt_fof--;
		}
		friend_bob[id_fob] = true;

		int m = 0;
		cin >> m;
		for(int j = 0; j < m; j++)
		{
			int id_fof = 0;
			cin >> id_fof;

			// Kiểm tra ID của bạn của bạn Bob xem có phải bạn của Bob không
			// và đã tồn tại hay chưa.
			// Nếu thỏa mãn thì đánh dấu là đã tồn tại để khỏi bị lặp và tăng biến đếm lên
			if(friend_bob[id_fof] == false && exist[id_fof] == false)
			{
				exist[id_fof] = true;
				cnt_fof++;
			}
		}
	}

	cout << cnt_fof << endl;
	return 0;
}

SPOJ.COM - Thuật toán bài CTAIN - Containers

admin@phamvanlam.com — Sat, 03 Dec 2016 19:46:00 GMT

Đề bài:

Bạn được đưa cho n thùng chứa, trong đó 1 <= n <= 4. Lúc đầu, tất cả chúng đều đầy nước. Dung lượng tối đa của thùng thứ i là một số tự nhiên o_i thỏa mãn 1 <= o_i <= 49.

Có 3 loại hành động có thể thực hiện:

Đổ toàn bộ nước từ một thùng sang một thùng khác
Đổ đầy một thùng với phần nước từ một thùng khác.
Đổ hết nước từ một thùng xuống cống

Nhiệm vụ:

Viết một chương trình cho mỗi test case:

Đọc vào số lượng thùng n, dung lượng tối đa của mỗi thùng và lượng nước được yêu cầu từ mỗi thùng.
Kiểm tra xem nếu tồn tại một chuỗi hành động có thể dẫn tới lượng nước yêu cầu của mỗi thùng, thì tính xem số bước nhỏ nhất để làm được việc đó.
In ra kết quả. Kết quả là số bước nhỏ nhất để đạt được yêu cầu hoặc in ra "NO" nếu không thể đạt được yêu cầu.

Đầu vào

Một số nguyên ở dòng đầu tiên, là số lượng test case, theo sau là một dòng trắng. Cho biết là sẽ không quá 20 test case.

Mỗi test case, dòng đầu tiên sẽ là một số nguyên dương n, với n <= 4 là số lượng thùng. Dòng tiếp theo là n số nguyên dương, là dung lượng tối đa của mỗi thùng o_i , thỏa mãn 1 <= o_i <= 49. Dòng tiếp theo sẽ là n số nguyên dương w_i, là lượng nước yêu cầu của mỗi thùng, thỏa mãn 0 <= w_i <= o_i. Tất cả số nguyên ở dòng thứ 2 và thứ 3 của mỗi test case được cách nhau bởi một dấu cách. Các test case được phân cách nhau bởi một dấu cách.

Đầu ra

Mỗi test case in ra một số nguyên - là số bước nhỏ nhất để đạt được yêu cầu. Ngược lại thì in ra "NO".

Ví dụ

Đầu vào:

Đầu ra:

6
NO

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/CTAIN/

Phân tích

Tại một thời điểm, ta sẽ có một trạng thái ứng với lượng nước trong mỗi thùng. Bài toán cho trước trạng thái ban đầu và yêu cầu tìm ra số bước nhỏ nhất để đạt được trạng thái đích. Do đó, mình sẽ dụng thuật toán tìm kiếm theo chiều rộng BFS để giải quyết bài toán.
Vì có tối đa là 4 thùng nên mình sẽ sử dụng mảng 4 chiều, trong đó mỗi chiều sẽ có tối đa 50 phần tử từ 0 đến 49 đại diện cho lượng nước từ 0 đến 49, để đánh dấu số bước nhỏ nhất có thể đạt được trạng thái đó. Ban đầu các giá trị của mảng sẽ được đánh dấu là MAX_INT. Sau quá trình duyệt nếu như giá trị của mảng tại trạng thái cần tìm vẫn là MAX_INT thì có nghĩa là sẽ không có cách để đạt được trạng thái đó và in ra là "NO". Ngược lại mình sẽ in ra giá trị của mảng tại trạng thái đó.
Tại một trạng thái thì các trạng thái kề với nó sẽ có được bằng cách thực hiện 3 hành động cho trong đề bài.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX = 5;
const int MAX_QUEUE = 1000000;
const int MAX_INT = 1 << 30;
const int MAX_STATE = 50;

int  N;				//số lượng thùng
int Capacity[MAX];	//dung lượng mối thùng
int Water[MAX];		//lượng nước hiện tại mỗi thùng
int Need[MAX]; 		//lượng nước cần
int Answer;			//kết quả
bool Flag, Finish;

// Đánh dấu trạng thái
int  State[MAX_STATE][MAX_STATE][MAX_STATE][MAX_STATE];

typedef struct Point
{
	int *water;
	int step;
	Point():step(0),water(0){}
	Point(int st, int *wa):step(st),water(wa){}
}Point;

Point queue[MAX_QUEUE];
int fr, re, leng;

/**
* copy mảng: từ mảng src sang mảng dst*/
void CpyArray(int *dst, int *src)
{
	for(int i = 0; i < N; i++)
		dst[i] = src[i];
}

// implement hàng đợi vòng
void Enqueue(Point p)
{
	queue[re] = p;
	re = (re + 1) % MAX_QUEUE;
	leng++;
}

Point Dequeue()
{
	Point p = queue[fr];
	fr = (fr + 1) % MAX_QUEUE;
	leng--;
	return p;
}

/**
* Lấy giá trị của mảng 4 chiều tại một trạng thái
*/
int GetValueState(int *tmp)
{
	int a,b,c,d;
	a = b = c = d = 0;

	if(N == 1) a = tmp[0];
	else if(N == 2) {a = tmp[0]; b = tmp[1];}
	else if(N == 3) {a = tmp[0]; b = tmp[1]; c = tmp[2];}
	else if(N == 4) {a = tmp[0]; b = tmp[1]; c = tmp[2]; d = tmp[3];}

	return State[a][b][c][d];
}

/**
* Xét giá trị value cho mảng 4 chiều tại trạng thái cho trước
*/
void SetValueState(int *tmp, int value)
{
	int a,b,c,d;
	a = b = c = d = 0;

	if(N == 1) a = tmp[0];
	else if(N == 2) {a = tmp[0]; b = tmp[1];}
	else if(N == 3) {a = tmp[0]; b = tmp[1]; c = tmp[2];}
	else if(N == 4) {a = tmp[0]; b = tmp[1]; c = tmp[2]; d = tmp[3];}

	State[a][b][c][d] = value;
}

// Implement BFS
void BFS(Point st)
{
	fr = re = leng = 0;
	SetValueState(st.water,0);
	Enqueue(st);

	while(leng > 0)
	{
		Point p = Dequeue();

		// Duyệt các thùng và thực hiện 3 hành động
		for(int i = 0; i < N; i++)
		{
			// Hành động 1: đổ hết nước đi
			int old_water = p.water[i];
			p.water[i] = 0;

			int *tmp1 = new int[N];
			CpyArray(tmp1, p.water);

			// Kiểm tra xem trạng thái này đã có chưa
			// nếu giá trị tại đó là MAX_INT nghĩa là chưa có
			if(GetValueState(tmp1) == MAX_INT)
			{
				SetValueState(tmp1, p.step + 1);
				Enqueue(Point(p.step + 1, tmp1));
			}
			p.water[i] = old_water;

			// Hành động 2: Đổ đầy bằng 1 thùng khác
			// Hành động này chỉ thực hiện khi thùng chưa đầy
			if(p.water[i] < Capacity[i])
			{
				// thử đổ đầy bằng các thùng còn lại
				for(int j = 0; j < N; j++)
				{
					if(j == i) continue;
					if(Capacity[i] - p.water[i] <= p.water[j])
					{
						int old_water1 = p.water[i], old_water2 = p.water[j];
						p.water[j] = p.water[j] - (Capacity[i] - p.water[i]);
						p.water[i] = Capacity[i];

						int *tmp2 = new int[N];
						CpyArray(tmp2,p.water);

						// Kiểm tra xem trạng thái này đã có chưa
						// nếu giá trị tại đó là MAX_INT nghĩa là chưa có
						if(GetValueState(tmp2) == MAX_INT)
						{
							SetValueState(tmp2,p.step+1);
							Enqueue(Point(p.step+1,tmp2));
						}
						p.water[i] = old_water1;
						p.water[j] = old_water2;
					}
				}
			}

			//Hành động 3: Đổ hết nước sang thùng khác nếu đủ chỗ
			//Xét thử các thùng
			for(int j = 0; j < N; j++)
			{
				if(j == i) continue;
				if(Capacity[j] - p.water[j] >= p.water[i])
				{
					int old_water1 = p.water[i], old_water2 = p.water[j];
					p.water[j] = p.water[j] + p.water[i];
					p.water[i] = 0;

					int *tmp3 = new int[N];
					CpyArray(tmp3,p.water);

					// Kiểm tra xem trạng thái này đã có chưa
					// nếu giá trị tại đó là MAX_INT nghĩa là chưa có
					if(GetValueState(tmp3) == MAX_INT)
					{
						SetValueState(tmp3,p.step+1);
						Enqueue(Point(p.step+1,tmp3));
					}
					p.water[i] = old_water1;
					p.water[j] = old_water2;
				}
			}
		}
	}
}

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);
	int T;
	cin >> T;
	for(int tc = 0; tc < T; tc++)
	{
		cin >> N;
		for(int i = 0; i < N; i++)
		{
			cin >> Capacity[i];
			Water[i] = Capacity[i];
		}

		for(int i = 0; i < N; i++)
			cin >> Need[i];

		Answer = MAX_INT;
		for(int i = 0; i < MAX_STATE; i++)
			for(int j = 0; j < MAX_STATE; j++)
				for(int k = 0; k < MAX_STATE; k++)
					for(int m = 0; m < MAX_STATE; m++)
						State[i][j][k][m] = MAX_INT;

		BFS(Point(0, Water));

		Answer = GetValueState(Need);

		if(Answer == MAX_INT) cout << "NO" << endl;
		else cout << Answer << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài CODFURY - Megatron and his rage

admin@phamvanlam.com — Thu, 01 Dec 2016 22:24:00 GMT

Đề bài:

Bị làm tức điên lên sau thất bại bởi cuộc tấn công của Decepticons, Megatron đã quyết định phá hủy tất cả những hành tinh trên đường trở về trái đất từ Cybertron. Có nhiều hành tinh giữa trái đất và Cybertron. Mỗi hành tinh có một vài con robot canh giữ trên đó. Bởi vì Megatron còn rất ít đạn dược nên anh ta muốn tấn công với ít robot nhất có thể. Biết anh ta không thể tấn công quá M robot.

Bạn hãy tìm ra số lớn nhất của những hành tinh mà anh ta có thể phá hủy trên hành trình của mình.

Chú ý: Megatron có thể bắt đầu cuộc tấn công từ bất kì một hành tinh nào. Và anh ta chỉ có thể di chuyển đến hành tinh bên cạnh hành tinh hiện tại anh ta đang ở đó.

Đầu vào

Đầu tiên là số T, là số lượng test case, T <= 20. Sau đó là T test case. Mỗi test case bắt đầu bằng một dòng chứa 2 số nguyên P và M. Trong đó, P là số lượng hành tinh và M là số lượng hành tinh tối đa mà anh ta có thể phá hủy. Với P <= 50000 và M <= 1000000. Sau đó là một dòng chứa P số nguyên phân biệt nhau bởi dấu cách, miêu tả số lượng robot trên mỗi hành tinh, giá trị này <= 1000.

Đầu ra

Đầu ra sẽ bao gồm T cặp số nguyên, một cặp trên một dòng xác định số lượng robot mà Megatron sẽ đánh và số hành tinh anh ta phá hủy.

Ví dụ

Đầu vào:

1
4 50
20 5 23 45

Đầu ra:

48 3

Giải thích:

Megatron bắt đầu từ hành tinh số 1, sau đó là hành tinh số 2, 3. Tại điểm này anh ta đã đánh được 48 robot. Lúc này anh ta đã phá hủy được 3 hành tinh rồi.
Megatron có thể bắt đầu từ hành tinh số 2 sau đó đến hành tinh số 3, 4. Tuy nhiên lúc này anh ta phải đánh 73 robot. Tuy nhiên anh ta muốn đánh số robot ít nhất nên anh ta sẽ chọn đánh từ hành tinh số 1 đến 2, 3.

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/CODFURY/

Phân tích

Bài toán này sử dụng thuật toán tham lam Greedy để giải. Cụ thể hơn là sử dụng phương pháp dịch cửa sổ. Cửa sổ ở đây có kích thước là M. Và ta sẽ dịch từ đầu đến cuối, rồi tìm ra trường hợp nào cho tổng robot là nhỏ nhất.

Lời giải

Code C/C++

#include<stdio.h>

int main()
{
	int T, P, M;
	scanf("%d",&T);
	for(int tc = 0; tc < T; tc++)
	{
		scanf("%d%d",&P,&M);

		int *a = new int[P];
		for(int i = 0; i < P; i++)
			scanf("%d",&a[i]);

		int st = 0, i = 0, sum = 0;
		int max_plannet = 0;
		int min_ammo = M + 1;
		while(i < P)
		{
			sum += a[i];
			if(sum > M)
			{
				int temp = i - st;
				int t = sum - a[i];
				if(temp > max_plannet)
				{
					max_plannet = temp;
					min_ammo = t;
				}
				else if(temp == max_plannet)
				{
					max_plannet = temp;
					if (t < min_ammo) min_ammo = t;
				}

				while(sum >= M)
				{
					sum -= a[st];
					st++;
				}
			}

			i++;
		}

		int temp = i - st;
		if(temp > max_plannet)
		{
			max_plannet = temp;
			min_ammo = sum;
		}
		else if(temp == max_plannet)
		{
			max_plannet = temp;
			if (sum < min_ammo) min_ammo = sum;
		}

		printf("%d %d\n",min_ammo,max_plannet);
		delete[] a;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài CUBEFR - Cube Free Numbers

admin@phamvanlam.com — Thu, 01 Dec 2016 22:24:00 GMT

Đề bài:

"Cube free number" là một số mà không có số chia nào của nó là số dạng lập phương (số dạng lập phương ví dụ như 8 (222)), 27(333). Do đó những số cube free number là 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 17, 18,...(ta xem xét 1 như là số cube free number). 8, 16, 24, 27, 32 không phải 8, 16, 24, 27, 32. Trong đó, vị trí của 1 trong dãy là 1, vị trí của 2 là 2, vị trí của 3 là 3, vị trí của 10 là 9. Cho trước một số dương, bạn hãy cho biết xem nó có phải là cube free number hay không, và nếu có thì chỉ ra vị trí của nó trong dãy.

Đầu vào

Dòng đầu tiên là là số T, số lượng test case, 1 <= T <= 100000. Sau đó là T dòng. Mỗi dòng là một số nguyên dương n, 1 <= n <= 1000000.

Đầu ra

Với mỗi test case, in ra một dòng dạng "Case I:", trong đó i là chỉ số của test case. Sau đó nếu nó không phải là cube free number thì in ra "Not Cube Free". Ngược lại thì in ra vị trí của nó trong dãy.

Ví dụ

Đầu vào:

Đầu ra:

Case 1: 1
Case 2: 2
Case 3: 3
Case 4: 4
Case 5: 5
Case 6: 6
Case 7: 7
Case 8: Not Cube Free
Case 9: 8
Case 10: 9

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/CUBEFR/

Phân tích

Mình sẽ sử dụng thuật toán tham lam Greedy để giải bài toán. Cụ thể hơn là sử dụng thuật toán sàng. Bởi lẽ dãy số chỉ có một, nên mình sẽ sinh ra dãy số một lần duy nhất.
Trước tiên, dùng một mảng đánh dấu, khởi tạo giá trị bằng 0. Duyệt các số i từ 2 đến 100, khi đó số dạng lập phương từ số đó là k = i*i*i. Suy ra số 1*k, 2*k, 3*k, ... sẽ không phải là cube free number và được đánh dấu -1. Ở đây, mình chỉ xét đến 100 vì 100*100*100 = 1000000, là đủ đến giá trị lớn nhất của n.
Sau khi đánh dấu những số không phải cube free number, mình sẽ duyệt một lượt nữa để đếm vị trí của những số cube free number và lưu luôn vào mảng đánh dấu trên.

Lời giải

Code C/C++

#include<stdio.h>

const int MAX = 1000001;
int free_cube[MAX];

void create_free_cube()
{
	for(int i = 2; i <= 100; i++)
	{
		int t = i*i*i;
		int j = 1;

		while(true)
		{
			int temp = t*j;
			if(temp < MAX)
			{
				free_cube[temp] = -1;
				j++;
			}
			else break;
		}
	}

	int cnt = 0;
	for(int i = 1; i < MAX; i++)
		if(free_cube[i] > -1)
		{
			cnt++;
			free_cube[i] = cnt;
		}
}

int main()
{
	int T = 0;
	scanf("%d",&T);

	for(int i = 0; i < MAX; i++)
	    free_cube[i] = 0;

	create_free_cube();

	for(int tc = 0; tc < T; tc++)
	{
		int n = 0;
		scanf("%d",&n);

		if(free_cube[n] == -1) printf("Case %d: Not Cube Free\n",tc+1);
		else printf("Case %d: %d\n",tc+1,free_cube[n]);
	}
	return 0;
}

SPOJ.COM - Thuật toán bài CANTON - Count on Cantor

admin@phamvanlam.com — Thu, 01 Dec 2016 22:00:00 GMT

Đề bài:

Một trong những phép chứng minh nổi tiếng trong toán học hiện đại là phép chứng minh của Georg Cantor về dãy những số hữu tỷ đếm được. Cái này thực hiện bằng cách sử dụng phép đếm những số hữu tỷ được trình bày như hình sau:

1/1 1/2 1/3 1/4 1/5 ...
2/1 2/2 2/3 2/4
3/1 3/2 3/3
4/1 4/2
5/1

Trên hình trên, số hạng đầu tiên là 1/1, thứ hai là 1/2, thứ 3 là 2/1, thứ tư là 3/1 và thứ 5 là 2/2, vân vân.

Đầu vào

Bắt đầu bằng số t, t <= 20, là số lượng test case. Sau đó là t test case. Mỗi test case chứa một số trên 1 dòng.

Đầu ra

Bạn hãy viết một chương trình để đọc danh sách các số, trong khoảng từ 1 đến 10^7 và in ra số hạng tương ứng theo cách đếm trên.

Ví dụ

Đầu vào:

Đầu ra:

TERM 3 IS 2/1
TERM 14 IS 2/4
TERM 7 IS 1/4

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/CANTON/

Phân tích

Mình sẽ sử dụng thuật toán tham lam Greedy để giải bài toán.

Nếu đánh số thứ tự cho các số từ 1, và coi mỗi đường chéo là một hàng thì mình sẽ có quy luật như sau:

Ta chỉ xét tới số nhỏ nhất của mỗi hàng là: 1, 2, 4, 7, ... sẽ có công thức như sau: x1 = 1 và x_n = 1 + (n*(n-1)) / 2 với n sẽ là chỉ số hàng.

Bạn có thể thay thử n vào sẽ thấy công thức trên đúng. Lúc này nếu như mình cần tìm số hạng thứ a. Mình có thể tìm được chỉ số của hàng chứa a bằng cách cho 1 + (n*(n-1)) / 2 = a. Suy ra: n = (1 + sqrt(8a-7))/2. Thực tế sẽ không đúng, tuy nhiên vì phép chia này là phép chia nguyên do đó kết quả cho ra là hoàn toàn đúng.

Bây giờ mình đã có được chỉ số hàng của hàng chứa a rồi là n. Suy ra số nhỏ nhất của hàng đó là: 1 + (n*(n-1)) / 2

Quy luật tiếp theo có thể thấy được là trên cùng một hàng thì tổng của tử số và mẫu số là như nhau với mọi số hạng và nó chính bằng chỉ số hàng + 1.

Cụ thể tiếp theo như nào xin mời bạn xem code của mình phía dưới nhé.

Lời giải

Code C/C++

#include <iostream>
#include <math.h>
using namespace std;

#define ull unsigned long long

/*	sum	 	term		id	x
*	 2		1			1	1
*	 3		2	3		2	2
*	 4		4	5	6	3	4
*	 5		7	8	9	4	7
*
*	1,2,4,7,...=> x1 = 1, x_n = 1 + n(n-1)/2;
*	we have term = a => 1 + n(n-1)/2 = a => n = (1 + sqrt(8a-7))/2
*/

int main()
{
	//freopen("input.txt","r",stdin);
	ull t = 0;
	cin >> t;
	for(int tc = 0; tc < t; tc++)
	{
		ull a = 0;
		cin >> a;

		ull id  = (1 + (ull) sqrt(8*a-7))/2;
		ull sum = id + 1;
		ull start = 1 + (id * (id-1))/ 2;
		ull delta = (a - start);

		ull y = 1;
		ull x = sum - y;

		x -= delta;
		y += delta;

		if(sum%2 == 0)
		{
			// form: x/y
			cout << "TERM " << a << " IS " << x << "/" << y << endl;
		}
		else
		{
			// form: y/x
			cout << "TERM " << a << " IS " << y << "/" << x << endl;
		}
	}
	return 0;
}

SPOJ.COM - Thuật toán bài CANDY - Candy I

admin@phamvanlam.com — Wed, 30 Nov 2016 23:00:00 GMT

Đề bài:

Jennifer là một giáo viên lớp một ở trường tiểu học. Cô ấy đã đi du lịch cùng với lớp của cô ngày hôm nay. Cô ấy đã lấy một gói chứa kẹo cho mỗi đứa trẻ. Không may kích thước của các gói là khác nhau.

Jennifer sợ rằng mỗi đứa trẻ sẽ muốn có gói lớn nhất và điều đó sẽ dẫn tới cãi vã, thậm chí là đánh nhau. Cô ấy muốn tránh điều đó. Vì vậy, cô ấy quyết định rằng sẽ mở tất cả các gói kẹo ra, đếm số kẹo ở mỗi gói và chuyển số kẹo từ gói lớn hơn sang gói nhỏ hơn, sao cho các gói có cùng số kẹo. Câu hỏi là số lượng cái kẹo cô ấy phải chuyển là bao nhiêu.

Đầu vào

Bao gồm nhiều test case. Mỗi test case sẽ bao gồm một số N, 1 <= N <= 10000 - là số lượng kẹo. Theo sau là N số nguyên, mỗi số đều nhỏ hơn 1000, là số lượng kẹo của mỗi gói.

Theo sau test case cuối cùng là số nguyên -1.

Đầu ra

Với mỗi test case in ra số lượng kẹo nhỏ nhất mà cô giáo phải di chuyển. Nếu không thể làm cho các gói kẹo có số lượng như nhau thì in ra giá trị -1.

Ví dụ

Đầu vào:

Đầu ra:

4
-1

Giải thích:

Test case 1: sẽ mất 4 lần di chuyển 4 viên kẹo ở gói có 6 viên sang các gói còn lại. Khi đó mỗi gói sẽ có 2 cái kẹo.
Test case 2: có 2 gói kẹo, 3 và 4 chiếc kẹo thì không thể làm cho chúng có số kẹo bằng nhau.

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/CANDY/

Phân tích

Rõ ràng thuật toán tham lam Greedy là phù hợp với bài toán này. Thật vậy, để di chuyển sao cho các gói kẹo có cùng số kẹo như nhau thì khi đó số kẹo của mỗi gói phải là tổng số kẹo chia cho tổng số lượng gói và bắt buộc phải là chia hết. Nếu không chia hết thì nghĩa là không thể di chuyển được để các gói có số lượng kẹo như nhau.

Khi đó, việc tính toán số bước di chuyển là vô cùng đơn giản.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int main()
{
	//freopen("input.txt","r",stdin);
	int n = 0;
	while(true)
	{
		cin >> n;
		if(n == -1) break;

		int sum = 0;
		int *a = new int[n];
		for(int i = 0; i < n; i++)
		{
			cin >> a[i];
			sum += a[i];
		}

		int moves = 0;
		if(sum % n != 0) moves = -1;
		else
		{
			int average = sum / n;
			for(int i = 0; i < n; i++)
				if(a[i] < average) moves += average - a[i];
		}

		cout << moves << endl;
		delete[] a;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài BYTESM2 - Philosophers Stone

admin@phamvanlam.com — Wed, 30 Nov 2016 22:40:00 GMT

Đề bài:

Một trong những phòng bí mật của Hogwarts là đầy đá. Sàn nhà của phòng có kích thước h x w, được lát bởi những viên đá hoa hình vuông. Trong đó h dòng tính từ trước ra sau và w cột tính từ trái sang phải. Mỗi viên đá hóa chứa 1 đến 100 viên đá trên đó. Harry phải nhặt nhiều đá nhất có thể và phải theo chỉ dẫn sau:

Anh ta chọn một viên đá hoa bất kì từ hàng trên cùng và sau đó nhặt lấy những viên đá trên đó. Sau đó, anh ta di chuyển đến viên đá hoa ở hàng tiếp theo, rồi lại nhặt những viên đá trên đó. Cứ như vậy tiếp tục cho đến khi anh ta đi đến hàng cuối cùng.
Khi anh ta di chuyển từ một viên đá hoa đến một viên đá hoa khác ở hàng tiếp theo, anh ta chỉ được phép di chuyển đến viên đá hoa ở phía dưới hoặc viên đá hoa ở chéo phía bên trái hay phải.

Cho trước giá trị của h, w và số lượng những viên đá trên mỗi ô vuông. Viết chương trình tính số lượng viên đá tối đa mà Harry có thể nhặt được khi đi từ hàng đầu tiên đến hàng cuối cùng.

Đầu vào

Dòng đầu tiên chứa số lượng test case T, 1 <= T <= 100. Mỗi test case, dòng đầu tiên chứa 2 số nguyên h và w, với h là số hàng và w là số cột, 1 <= h, w <= 100. Tiếp theo sẽ là h dòng, mỗi dòng chứa w giá trị - là số lượng những viên đá trên mỗi ô, gọi là m, 0 <= m <= 100. Các số nguyên được phân cách nhau bởi một dấu cách.

Đầu ra

Với mỗi test case, in ra một dòng chứa một số nguyên, là số lượng viên đá tối đa mà Harry có thể thu thập được theo quy tắc đã nêu ở trên.

Ví dụ

Đầu vào:

Đầu ra:

Giải thích:

Harry sẽ đi theo các ô có số lượng đá là: 7 + 1 + 8 + 5 + 4 + 7 = 32

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/BYTESM2/

Phân tích

Mình sẽ sử dụng thuật toán quy hoạch động Dynamic programming, viết theo kiểu bottom up (dùng vòng lặp) để giải quyết bài toán.

Mình sẽ sử dụng một mảng hai chiều để lưu số lượng đá lớn nhất tại mỗi ô khi đi từ trên xuống dưới ô đó. Chú ý là khi đi từ trên xuống ta chỉ có thể đi xuống dưới, hoặc chéo trái, hoặc chéo phải.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int h, w;
int Matrix[101][101];	// Lưu giá trị lớn nhất tại mỗi ô

int main()
{
	int Testcase;
	cin >> Testcase;
	for(int tc = 0; tc < Testcase; tc++)
	{
		// Nhập đầu vào
		cin >> h >> w;
		for(int row = 0; row < h; row++)
			for(int col = 0; col < w; col++)
				cin >> Matrix[row][col];

		// Bắt đầu xét từ dòng thứ 2
		for(int row = 1; row < h; row++)
		{
			for(int col = 0; col < w; col++)
			{
				int left = 0, above = 0, right = 0, temp = 0;

				// Tại một ô, tôi sẽ kiểm tra giá trị của 3 ô phía trước nó
				// là trên trái, trên phải và điểm ngay phía trên
				if(col > 0)		left = Matrix[row-1][col-1];
				if(col < w-1)	right= Matrix[row-1][col+1];
				above = Matrix[row-1][col];

				// Tìm ra trường hợp lớn nhất
				int max = left;
				if(right > max) max = right;
				if(above > max) max = above;

				Matrix[row][col] += max;
			}
		}

		// Tìm ra giá trị lớn nhất ở hàng cuối cùng
		int max_stone = 0;
		for(int col = 0; col < w; col++)
			if(Matrix[h-1][col] > max_stone) max_stone = Matrix[h-1][col];

		cout << max_stone << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài BUGLIFE - A Bug's Life

admin@phamvanlam.com — Wed, 30 Nov 2016 22:10:00 GMT

Đề bài:

Giáo sư Hopper đang nghiên cứu về hành vi giới tính của một dạng hiếm có của loài bọ. Ông ta giả sử rằng chúng chia ra làm 2 giới tính khác nhau. Và chúng chỉ tương tác với những loài có giới tính khác. Theo nghiên cứu của ông, những con bọ riêng lẻ và hành vi của chúng rất dễ để nhận ra. Bởi vì những số được in trên lưng của chúng.

Cho trước một danh sách sự tương tác giữa những con bọ. Hãy quyết định xem nếu như những nghiên cứu ủng hộ giả sử của ông ta rằng không có tình dục đồng giới hoặc có tồn tại điều đó.

Đầu vào

Dòng đầu tiên chứa số lượng test case. Mỗi test case bắt đầu với một dòng gồm 2 số. Số thứ nhất là số con bọ (giá trị thuộc từ 1 đến 2000) và số tương tác (giá trị lên đến 1000000) được phân cách nhau bởi dấu cách. Các dòng tiếp theo, mỗi dòng mô tả một tương tác, gồm 2 số nguyên khác nhau, là chỉ số của con bọ. Các con bọ được đánh số liên tiếp và bắt đầu từ 1.

Đầu ra

Với mỗi test case, sẽ là một dòng dạng "Scenario #i:" với i là chỉ số test case, bắt đầu từ 1. Theo sau bởi một dòng là "No suspicious bugs found!" nếu phù hợp với giả sử của giáo sư là không có tình dục đồng giới. Ngược lại thì là "Suspicious bugs found!".

Ví dụ

Đầu vào:

Đầu ra:

Scenario #1:
Suspicious bugs found!
Scenario #2:
No suspicious bugs found!

Giải thích:

Với test case 1: có điều khả nghi được tìm thấy. Vì 1 tương tác với 2 nên chứng tỏ 1 và 2 khác giới nhau. Tiếp theo 2 tương tác với 3 chứng tỏ 2 và 3 khác giới nhau. Từ hai điều trên suy ra 1 và 3 phải cùng giới. Nhưng 1 và 3 lại có tương tác. Từ đó, suy ra có hiện tượng tình dục đồng giới.
Với test case 2: rõ ràng thỏa mãn không có tình dục đồng giới.

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/BUGLIFE/

Phân tích

Rõ ràng đây là bài toán chia đôi đồ thị. Mình sẽ sử dụng thuật toán tìm kiếm theo chiều sâu DFS để duyệt các con bọ và đánh số các con bọ theo quy luật là 2 con bọ có tương tác với nhau sẽ được đánh dấu khác nhau (ví dụ 1 và 2).
Do đó, những con bọ được đánh dấu cùng loại sẽ có cùng giới tính. Như vậy, nếu 2 con bọ nào được đánh dấu cùng loại mà lại có tương tác thì suy ra kết quả là tồn tại tình dục đồng giới. Ngược lại sẽ là không.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 2005;

int N;		// số lượng bọ
int I;		// số lượng tương tác
int Answer;	// kết quả 1 : nếu tồn tại tình dục đồng giới

int Matrix[MAX][MAX];	// Đánh dấu tồn tại cạnh giữa 2 điểm
int Mark[MAX];			// Mảng đánh dấu loại các con bọ

/**
* u : điểm đang xét
* before: điểm trước đó
* type: loại của điểm đang xét
*/
void DFS(int u, int before, int type)
{
	Mark[u] = type;
	for(int i = 1; i <= Matrix[u][0] && !Answer; i++)
	{
		int v = Matrix[u][i];
		if(Mark[v] == -1)
		{
			// Nếu chưa duyệt thì duyệt và đánh dấu loại khác với điểm trước đó
			DFS(v, u, !type);
		}
		else if(v != before && Mark[v] == type)
		{
			// Nếu gặp một điểm mà được xét rồi và cùng loại thì có tình dục đồng giới
			// Lúc này dừng lại luôn.
			Answer = 1;
			return;
		}
	}
}

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);

	int T;
	cin >> T;
	for (int tc = 0; tc < T; tc++)
	{
		// Nhập đầu vào
		Answer = 0;
		cin >> N >> I;
		for(int i = 0; i <= N; i++)
		{
			Mark[i] = -1;
			for(int j = 0; j <= N; j++)
				Matrix[i][j] = 0;
		}

		int a, b, m;
		for(int i = 1; i <= I; i++)
		{
			cin >> a >> b;

			m = ++Matrix[a][0];
			Matrix[a][m] = b;

			m = ++Matrix[b][0];
			Matrix[b][m] = a;
		}

		// Tìm những điểm chưa được duyệt thì sẽ duyệt
		for(int i = 1; i <= N; i++)
			if(Mark[i] == -1)
				DFS(i,-1,0);

		// Đầu ra
		cout << "Scenario #" << tc + 1  << ":"<< endl;
		if (Answer) cout << "Suspicious bugs found!" << endl;
		else cout << "No suspicious bugs found!" << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài BROKEN - Broken Keyboard

admin@phamvanlam.com — Tue, 29 Nov 2016 23:08:00 GMT

Đề bài:

Bàn phím của Bruce Force bị hỏng, chỉ một vài phím là vẫn còn hoạt động. Bruce đã nhận ra rằng anh ấy vẫn có thể viết chữ bằng việc thay đổi cách bố trí của các phím mỗi khi anh ấy cần nhập chữ cái mà hiện tại nó không thuộc m chữ cái còn hoạt động.

Bạn được đưa cho một dòng chữ mà Bruce muốn gõ. Và anh ấy yêu cầu bạn để nói cho anh ấy biết số lượng tối đa của những kí tự liên tiếp trong dòng chữ mà có thể được gõ mà không phải thay đổi cách bố trí của các kí tự trên bàn phím. Để đơn giản, chúng ta giả sử rằng mỗi phím trên bàn phím chỉ đại diện cho một chữ cái và không thể gõ chữ cái khác bằng việc gõ tổ hợp phím. Điều này có nghĩa là Bruce muốn biết độ dài lớn nhất của xâu con của dòng chữ cho ban đầu - cái mà bao gồm tối đa m kí tự khác nhau.

Đầu vào

Bao gồm nhiều test case, mỗi test case bao gồm 2 dòng. Dòng đầu tiên bao gồm số nguyên m (1 ≤ m ≤ 128), xác định số phím trên bàn phím còn hoạt động. Dòng thứ 2 của mỗi test case chứa dòng chữ mà Bruce muốn gõ. Giả sử rằng độ dài của dòng chữ không vượt quá 1000000 kí tự. Chú ý rằng dòng chữ đầu vào có thể chứa nhiều dấu cách, và dấu cách được xử lí giống như những kí tự khác.

Test case cuối cùng theo sau bởi một dòng chứa số 0.

Đầu ra

Mỗi test case in ra trên một dòng độ dài lớn nhất cần tìm.

Ví dụ

Đầu vào:

5
This can't be solved by brute force.
1
Mississippi
0

Đầu ra:

7
2

Giải thích:

Test case thứ nhất: xâu con thỏa mãn là: "by_bru" ('' biểu diễn dấu cách)
Test case thứ hai: xâu con thỏa mãn là: "ss"

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/BROKEN/

Phân tích

Mình sẽ sử dụng thuật toán tham lam Greedy để giải bài toán.
Ở đây mình sẽ sử dụng 2 biến để đánh dấu vị trí bắt đầu và vị trí đang xét hiện tại. Xâu con đang xét chính là xâu con từ vị trí bắt đầu đến vị trí hiện tại. Và mình sẽ duyệt từ đầu cho đến cuối của dãy.
Đồng thời mình sử dụng một mảng đếm số lượng các kí tự hiện tại. Từ đó mình tính được số kí tự khác nhau của xâu con. Trong quá trình duyệt mình sẽ tìm được xâu con có độ dài lớn nhất.
Cụ thể mời bạn xem code phía dưới để hiểu rõ hơn về thuật toán tham lam của mình.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

char str[1000005];  // Lưu xâu đầu vào
int  cnt[1000];     // Mảng đếm tần suất xuất hiện của kí tự

int main()
{
	freopen("input.txt","r",stdin);
	ios::sync_with_stdio(false);

	int m = -1, length = 0;
	char gar;
	while(true)
	{
		// Nhập đầu vào và tính độ dài của xâu
		cin >> m;
		if (m == 0) break;
		gar = cin.get();

		length = 0;
		cin.getline(str, 1000005);
		while(str[length] != '\0') length++;

		for(int i=0; i<1000;i++)
			cnt[i] = 0;

		//////////////////////////
		int _max = 0;			// Độ dài xâu con lớn nhất thỏa mãn
		int start = 0;			// chỉ số bắt đầu
		int id = 0;				// chỉ số hiện tại
		int numDiffChar = 0;	// số kí tự khác nhau từ chỉ số bắt đầu đến chỉ số hiện tại

		// Duyệt từ đầu đến cuối xâu
		while(id < length)
		{
			// Giá trị mảng đếm = 0 nghĩa là kí tự đó chưa tồn tại
			if(cnt[str[id]] == 0)
			{
				// Nếu số kí tự khác nhau nhỏ hơn m thì ta sẽ cho kí tự đó vào xâu con
				// đồng thời tăng giá trị biến đếm số lần xuất hiện của kí tự, số kí tự khác nhau
				// và chỉ số hiện tại
				if(numDiffChar < m)
				{
					cnt[str[id]] = 1;
					numDiffChar++;
					id++;
				}
				else if(numDiffChar == m)
				{
					// Nếu số kí tự khác nhau đã bằng m rồi
					// thì ta không thể thêm kí tự mới vào, khi đó số kí tự khác nhau sẽ là m + 1
					// Do đó tôi phải dịch chỉ số bắt đầu lên cho đến khi số kí tự khác nhau < m
					// Lúc đó mới có thể thêm kí tự mới.
					int t = id - start;
					if(t > _max) _max = t;

					while(numDiffChar == m)
					{
						cnt[str[start]]--;
						if(cnt[str[start]] == 0) numDiffChar--;
						start++;
					}
				}
			}
			else
			{
				// Trường hợp kí tự đó đã xuất hiện trong xâu con rồi
				// thì tôi chỉ cần biến đếm số lần xuất hiện của kí tự đó.
				cnt[str[id]]++;
				id++;
			}
		}

		int t = id - start;
		if(t > _max) _max = t;
		cout << _max << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài APS - Amazing Prime Sequence

admin@phamvanlam.com — Tue, 29 Nov 2016 22:21:00 GMT

Đề bài:

Bablu rất yêu thích với những dãy số. Sau khi học về dãy số Fibonaci ở lớp 9, anh ấy đã rất ấn tượng với nó và đã thiết kế ra một dãy số cho riêng mình theo quy luật sau:

a[0] = a[1] = 0; 
Với n > 1 thì a[n] = a[n-1] + f(n) với f(n) là thừa số nguyên tố nhỏ nhất của n.

Bablu cũng rất yêu thích lập trình. Vì vậy, anh ta đã viết ra một chương trình để tìm ra a[n]. Nhưng bởi vì anh ấy mới học lớp 9 nên anh ấy không giỏi về lập trình. Do đó, anh ấy nhờ bạn giúp đỡ. Nhiệm vụ của bạn là phải tìm ra số a[n] của dãy trên.

Đầu vào

Sẽ có nhiều test case. Dòng đầu tiên là số T - số lượng test case, T <= 100. T dòng tiếp theo chứa 1 số nguyên duy nhất N thỏa mãn 1 < N < 10^7.

Đầu ra

Mỗi test case, in ra số a[N].

Ví dụ

Đầu vào:

Đầu ra:

2
5
7

Giải thích:

Dãy số sẽ như sau:

a[0] = a[1] = 0; 
a[2] = a[1] + f[2] = 0 + 2 = 2; vì thừa số nguyên tố nhỏ nhất của 2 là 2. 
a[3] = a[2] + f[3] = 2 + 3 = 5; vì thừa số nguyên tố nhỏ nhất của 3 là 3. 
a[4] = a[3] + f[4] = 5 + 2 = 7; vì thừa số nguyên tố nhỏ nhất của 3 là 2.

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/APS/

Phân tích

Ta sẽ sử dụng thuật toán tham lam để giải quyết bài toán. Với bài toán này, ta không thể tính lại dãy số với mỗi test case được. Vì như vậy sẽ dẫn đến time limit.
Vì dãy số chỉ có một nên ta sẽ sinh ra dãy số 1 lần. Rồi sau đó, với mỗi giá trị của N ta sẽ in ra a[N].
Ta sẽ sử dụng một mảng để đánh dấu xem số i có phải là số nguyên tố hay không. Đồng thời lưu lại thừa số nguyên tố nhỏ nhất của i. Giả sử dùng mảng a[]. Khi đó nếu a[i] = 0 thì số i là số nguyên tố, a[i] = k thì số i không phải là số nguyên tố và thừa số nguyên tố nhỏ nhất của i là k.
Sau đó, mình sẽ dùng một mảng để lưu dãy số cần tìm, giả sử là dãy r[]. Khi đó với mỗi số i: nếu a[i] không là số nguyên tố thì r[i] = r[i - 1] + a[i]. nếu a[i] là số nguyên tố thì r[i] = r[i - 1] + i (vì thừa số nguyên tố nhỏ nhất của một số nguyên tố là chính nó).

Lời giải

Code C/C++

#include<iostream>
using namespace std;

typedef unsigned long long ll;
const ll MAX = 10000003;

ll a[MAX];  // Đánh dấu số i là số nguyên tố hay không
ll r[MAX];  // Lưu kết quả

void create()
{
    // Khởi tạo số nguyên tố đánh dấu là 0
	for(ll i = 2; i < MAX; i++)
	{
		a[i] = 0;
		r[i] = 0;
	}

    // Sinh ra dãy số theo quy luật:
    // nếu a[i] là số nguyên tố thì a[k.i] không phải số nguyên tố
    // và thừa số nguyên tố lớn nhất của k.i là i
	for (ll i = 2; i*i < MAX; i++)
        if (!a[i])
            for (ll j = i; j < MAX; j += i)
                if (!a[j])
                    a[j] = i;

    // Nếu a[i] khác 0 thì i là không là số nguyên tố và thừa số nguyên tố
    // lớn nhất của i là a[i]
    // ngược lại thì i là số nguyên tố và thừa số lớn nhất của i là i
    for (ll i = 2; i < MAX; i++)
	{
		if(a[i]) r[i] = r[i - 1] + a[i];
		else r[i] = r[i - 1] + i;
	}
}

int main()
{
	create();

	ll T = 0;
	cin >> T;
	for(ll tc = 0; tc < T; tc++)
	{
		ll n = 0;
		cin >> n;
		cout << r[n] << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài ACPC10A - What's Next

admin@phamvanlam.com — Tue, 29 Nov 2016 21:49:00 GMT

Đề bài:

Theo Wikipedia, cấp số cộng (arithmetic progression - AP) là một dãy số mà độ chênh lệch giữa hai số liên tiếp của các phần tử trong dãy là như nhau. Ví dụ, dãy số sau là một cấp số cộng: 3, 5, 7, 9, 11, 13,... với độ chênh lệch là 2, gọi là công sai của cấp số cộng. Trong bài toán này, ta giới hạn công sai sẽ là một số nguyên khác 0.

Mặt khác, cấp số nhân (geometric progression - GP) là dãy số mà số sau có được bằng cách lấy số đằng trước nhân với một số nguyên khác 0, số đó gọi là công bội. Ví dụ, dãy sau là một cấp số nhân: 2, 6, 18, 54,... với công bội là 3. Trong bài toán này, ta cũng giới hạn công bội là số nguyên khác 0.

Cho 3 số liên tiếp của dãy số, bạn hãy xác định xem dãy số đó là cấp số cộng hay cấp số nhân và số tiếp theo là gì.

Đầu vào

Chương trình của bạn sẽ được kiểm tra với một hay nhiều test case. Mỗi test case sẽ xác định trên 1 dòng với 3 số a1, a2, a3 thỏa mãn -10000 < a1, a2, a3 < 10000 và các số là khác nhau. Test case cuối cùng theo sau bởi 3 số 0.

Đầu ra

Với mỗi test case in ra kết quả dạng: XX v Trong đó, XX là AP hoặc GP tương ứng với dãy cho ban đầu là cấp số cộng hay cấp số nhân và v là số tiếp theo. Tất cả đầu vào đảm bảo thuộc AP hoặc GP.

Ví dụ

Đầu vào:

4 7 10
2 6 18
0 0 0

Đầu ra:

AP 13
GP 54

Giải thích:

Test case 1 là cấp cố cộng với công sai là 3
Test case 2 là cấp số nhân với công bội là 3

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/ACPC10A/

Phân tích

Bài toán này thuộc thuật toán tham lam Greedy
Vì đầu vào đảm bảo thuộc 2 loại AP hoặc GP nên mình xét xem trường hợp nào thỏa mãn thì nhận. Còn việc tìm số tiếp theo thì hoàn toàn đơn giản là dựa vào định nghĩa của AP và GP.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int main()
{
	//freopen("input.txt","r",stdin);
	int a1, a2, a3;
	while(true)
	{
		cin >> a1 >> a2 >> a3;
		if(a1 == 0 && a2 == 0 && a3 == 0) break;

		int different = a2 - a1;
		if(a2 + different == a3)
		{
			cout << "AP " << a3 + different << endl;
		}
		else
		{
			int ratio = a2/a1;
			cout << "GP " << a3 * ratio << endl;
		}
	}
	return 0;
}

SPOJ.COM - Thuật toán bài RENT - Rent your airplane and make money

admin@phamvanlam.com — Tue, 22 Nov 2016 21:14:00 GMT

Đề bài:

"ABEAS Corp." là một công ty rất nhỏ sở hữu duy nhất một chiếc máy bay. Khách hàng của "ABEAS Corp." là những công ty lớn - những công ty đã thuê để điều tiết khi lượng hàng hóa quá tải. Khách hàng gửi những đơn hàng bao gồm thời gian và giá mà khách hàng sẵn sàng trả cho việc thuê máy bay trong thời gian đó. Tất cả những đơn hàng đã được biết trước. Dĩ nhiên không phải tất cả các đơn hàng đều được chấp nhận, và một vài cái sẽ bị từ chối. Eugene LAWLER, "ABEAS Corp." muốn đạt được lợi nhuận cao nhất.

Bạn được yêu cầu tính toán giải pháp tối ưu này.

Một ví dụ nhỏ:

Xem xét một trường hợp đó là có 4 đơn hàng như sau:

Đơn hàng 1: (Thời gian bắt đầu 0, thời gian sử dụng 5, giá 10)
Đơn hàng 2: (Thời gian bắt đầu 3, thời gian sử dụng 7, giá 8)
Đơn hàng 3: (Thời gian bắt đầu 5, thời gian sử dụng 9, giá 7)
Đơn hàng 4: (Thời gian bắt đầu 6, thời gian sử dụng 9, giá 8)

Giải pháp tối ưu là bỏ đi đơn hàng 2 và 3, khi đó lợi nhuận sẽ là 10 + 8 = 18. Chú ý rằng, giải pháp chọn lựa đơn hàng 1 và 3 cũng thỏa mãn về mặt thời gian. Tuy nhiên, lợi nhuận chỉ là 10 + 7 = 17.

Đầu vào

Dòng đầu tiên là số T, số lượng test case, T <= 30. Dòng đầu của mỗi test case là số n, n <= 10000. Tiếp theo là n dòng, mỗi dòng là một đơn hàng, bao gồm 3 số nguyên, lần lượt là thời gian bắt đầu (st), thời gian sử dụng (d) và giá (p), với điều kiện là 0 <= st, d <= 1000000 và 0 <= p < 100000.

Đầu ra

Với mỗi test case, in ra số cần tìm.

Ví dụ

Đầu vào:

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/RENT/

Phân tích

Ở đây mình sử dụng kết hợp thuật toán tham lam Greedy, thuật toán chia để trị Divide and conquer và thuật toán quy hoạch động Dynamic programming.

Trong đó, thuật toán tham lam thể hiện ở chỗ đó là đầu tiên mình sẽ sử dụng thuật toán sắp xếp nhanh quick sort để sắp xếp các đơn hàng theo thời gian kết thúc tăng dần.

Tiếp theo, thuật toán quy hoạch động thể hiện ở chỗ đó là mình dùng một mảng, trong đó Memo[i] để lưu lại số tiến lớn nhất thu được khi chỉ chọn các đơn hàng từ 1 đến i. Như vậy rõ ràng kết quả cần tìm là Memo[N].

Trường hợp cơ sở ở đây là Memo[i] = Price[i] - tức là chỉ chọn 1 đơn hàng thứ i.

Ta có công thức quy hoạch động là Memo[i] = Max{Memo[i], Memo[i - 1], Price[i] + Memo[k]}

Trong đó: Memo[i - 1] ứng với trường hợp không chọn đơn hàng thứ i; Price[i] + Memo[k] ứng với trường hợp chọn đơn hàng thứ i, và k là số lớn nhất thỏa mãn thời gian kết thúc tại k < thời gian bắt đầu tại i - đảm bảo thời gian không bị chồng lên nhau.

Để tìm ra số k nhanh nhất mình sử dụng thuật toán chia để trị hay tìm kiếm nhị phân.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 10005;

int N;
int Start[MAX], Finish[MAX], Price[MAX];
long long Memo[MAX];
// Memo[i] là số tiền lớn nhất khi chỉ chọn các đơn hàng từ 1 đến i

void QuickSort(int left, int right)
{
	int l = left, r = right;
	int pivot = Finish[(l + r) / 2];

	while(l <= r)
	{
		while(Finish[l] < pivot) l++;
		while(Finish[r] > pivot) r--;

		if(l <= r)
		{
			int temp1 = Finish[l];	int temp2 = Start[l];	int temp3 = Price[l];
			Finish[l] = Finish[r];	Start[l] = Start[r];	Price[l] = Price[r];
			Finish[r] = temp1;		Start[r] = temp2;		Price[r] = temp3;
			l++;
			r--;
		}
	}

	if(l < right) QuickSort(l, right);
	if(left < r) QuickSort(left, r);
}

// Tìm số k lớn nhất thoả mãn Finish[k] < Start[i]
// Nếu không tìm thấy thì trả về -1
int BinarySearch(int i)
{
	int left = 1, right = i;
	int k;

	while(left < right - 1)
	{
		k = (left + right) / 2;

		if(Finish[k] < Start[i]) left = k;
		else right = k - 1;
	}

	if(Finish[right] < Start[i]) return right;
	if(Finish[left] < Start[i]) return left;
	return -1;
}

int main(int argc, char** argv)
{
	int T, test_case;
	//freopen("input.txt", "r", stdin);
	ios::sync_with_stdio(false);

	cin >> T;
	for(test_case = 0; test_case  < T; test_case++)
	{
		// Nhập đầu vào
		int d;
		cin >> N;
		for(int i = 1; i <= N; i++)
		{
			cin >> Start[i] >> d >> Price[i];
			Finish[i] = Start[i] + d;
		}

		// Sắp xếp các đơn hàng theo chiều tăng của thời gian kết thúc
		QuickSort(1, N);

		// Trường hợp cơ sở
		for(int i = 1; i <= N; i++)
			Memo[i] = (long long)Price[i];

		for(int i = 2; i <= N; i++)
		{
			// Không chọn đơn hàng thứ i
			if(Memo[i-1] > Memo[i]) Memo[i] = Memo[i-1];

			// Chọn đơn hàng thứ i
			// Tìm số k lớn nhất sao cho Finish[k] < Start[i]
			int k = BinarySearch(i);
			long long temp = (long long)Price[i] + (long long)Memo[k];
			if(k > -1 && temp > Memo[i]) Memo[i] = temp;
		}

		// Print the answer to standard output(screen).
		cout << Memo[N] << endl;
	}
	return 0;//Your program should return 0 on normal termination.
}

SPOJ.COM - Thuật toán bài INVCNT - Inversion Count

admin@phamvanlam.com — Tue, 08 Nov 2016 19:03:00 GMT

Đề bài:

Cho một mảng gồm N phần tử là số nguyên dương, phân biệt A[0....N-1]. Nếu i < j và A[i] > A[j] thì cặp (i, j) gọi là một cặp đảo nghịch. Cho số N và mảng A. Nhiệm vụ của bạn là tìm ra số cặp đảo nghịch.

Đầu vào

Dòng đầu tiên là số nguyên t - số lượng test case, theo sau là một khoảng trống. Mỗi test case bắt đầu bằng số N, N <= 200000. Sau đó là N + 1 dòng, với dòng thứ i là phần tử A[i - 1], A[i - 1] <= 10^7. Dòng thứ N + 1 là dòng trống.

Đầu ra

Mỗi test case in ra trên 1 dòng là số cặp đảo nghịch.

Ví dụ

Đầu vào:

Đầu ra:

2
5

Giải thích:

Test case 1: có 2 cặp đảo nghịch là (3, 1) và (3, 2)
Test case 2: có 5 cặp đảo nghịch là (2, 1), (3, 1), (8, 6), (8, 1) và (6, 1)

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/INVCNT/

Phân tích

Mình sẽ sử dụng thuật toán tham lam Greedy để giải bài toán. Cụ thể hơn là mình sẽ sử dụng thuật toán sắp xếp trộn Merge Sort để giải quyết.
Mình sẽ sắp xếp dãy đã cho theo thứ tự giảm dần. Và trong quá trình trộn mình sẽ cập nhật kết quả. Nghe tới đây có vẻ khó hiểu, xin mời bạn theo dõi code dưới đây để hiểu rõ hơn.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX = 200005;

long long Answer;
int N, T;
int A[MAX];

void Merge(int *a, int left, int m, int right)
{
	int *temp = new int[right - left + 1];
	int k = 0, i = left, j = m + 1;

	while(i <= m && j <= right)
	{
		if(a[i] > a[j])
		{
			temp[k++] = a[i++];

			// Rõ ràng ở đây i < j mà a[i] > a[j]
			// thì ta đã có cặp đảo nghịch ở đây.
			// Hơn nữa, bạn để ý rằng, vì tôi sắp xếp dãy giảm dần
			// nên nếu a[i] > a[j] thì a[i] cũng sẽ lớn hơn các số ở nhánh phải
			// chú ý là tôi đang trộn 2 nhánh đã sắp xếp, nên a[j] là số lớn nhất
			// nghĩa là tôi có thêm (right - j + 1) cặp đảo nghịch
			Answer += right - j + 1;
		}
		else
		{
			temp[k++] = a[j++];
		}
	}

	while(i <= m) temp[k++] = a[i++];
	while(j <= right) temp[k++] = a[j++];

	for(int i = 0; i < k; i++)
		a[i + left] = temp[i];
	delete[] temp;
}

void MergeSort(int *a, int left, int right)
{
	int m;
	if(left < right)
	{
		m = (left + right) / 2;
		MergeSort(a, left, m);
		MergeSort(a, m + 1, right);
		Merge(a, left, m, right);
	}
}

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);

	cin >> T;
	for(int tc = 0; tc < T; tc++)
	{
		//input
		Answer = 0;
		cin >> N;
		for(int i = 0; i < N; i++)
			cin >> A[i];

		// implementing code below
		MergeSort(A, 0, N-1);

		//output
		cout << Answer << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài KOIREP - Representatives

admin@phamvanlam.com — Mon, 07 Nov 2016 23:04:00 GMT

Đề bài:

Có N lớp ở trường và mỗi lớp có M học sinh. Sắp tới có một cuộc thi chạy 100 m và người đại diện cho mỗi lớp sẽ được chọn để tham gia cuộc thi. Bạn được giao cho một nhiệm vụ là chọn ra những người đại diện này. Bởi vì, bạn không muốn cuộc đua trở nên 1 chiều, nên bạn muốn chọn người đại diện của các lớp sao cho chênh lệnh khả năng giữa người tốt nhất và người kém nhất là ít nhất.

Ví dụ: Nếu N = 3 và M = 4. Mỗi lớp có những học sinh với khả năng như sau:

Lớp 1: {12,16,67,43}
Lớp 2: {7,17,68,48}
Lớp 3: {14,15,77,54}

Trường hợp tốt nhất là chọn ra học sinh với khả năng 16 ở lớp 1, học sinh có khả năng 17 ở lớp 2 và học sinh có khả năng 15 ở lớp 3. Khi đó, độ chênh lệch là: 17 - 15 = 2.

Nhiệm vụ của bạn là hãy tìm ra độ chênh lệch nhỏ nhất có thể bởi việc chọn ra người đại diện cho mỗi lớp.

Đầu vào

Dòng đầu tiên là số N và M (1<=N<=1000, 1<=M<=1000). N dòng tiếp theo, mỗi dòng có M số - miêu tả khả năng của các học sinh. Khả năng của học sinh là một con số trong khoảng từ 0 đến 10^9.

Đầu ra

In ra độ chênh lệch nhỏ nhất cần tìm.

Ví dụ

Trường hợp 1:

Đầu vào:

3 4
12 16 67 43
7 17 68 48
14 15 77 54

Đầu ra:

Trường hợp 2:

Đầu vào:

4 3
10 20 30
40 50 60
70 80 90
100 110 120

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/KOIREP/

Phân tích

Mình sẽ sử dụng thuật toán tham lam Greedy để giải bài toán.
Ở đây, trước tiên mình dùng sắp xếp trộn để sắp xếp tất cả người của các lớp theo thứ tăng dần về khả năng.
Tiếp đến mình sẽ dùng phương pháp cửa sổ để duyệt dãy đã sắp xếp. Cửa sổ ở đây có độ dài là n để tìm ra dãy n người thỏa mãn thuộc n lớp khác nhau. Khi đó, mình chỉ cần tìm ra trong các trường hợp đó trường hợp có độ chênh lệnh nhỏ nhất. Đó chính là kết quả của bài toán.

Lời giải

Code C/C++

#include<stdio.h>

typedef struct{
	int group;
	int ability;
}Person;

Person person[1000005];
int leng;
int cnt[1000];

// Sắp xếp trộn
void Merge(Person *p, int left, int m, int right)
{
	int l = left, r = m + 1, k = 0;
	Person *temp = new Person[right - left + 1];

	while(l <= m && r <= right)
	{
		if(p[l].ability < p[r].ability) temp[k++] = p[l++];
		else temp[k++] = p[r++];
	}

	while(l <= m) temp[k++] = p[l++];
	while(r <= right) temp[k++] = p[r++];

	for(int i = 0; i < k; i++)
		p[i+left] = temp[i];
	delete[] temp;
}

void MergeSort(Person *p, int left, int right)
{
	int m;
	if(left < right)
	{
		m = (left + right)/2;
		MergeSort(p,left,m);
		MergeSort(p,m+1,right);
		Merge(p,left,m,right);
	}
}

int main()
{
	int n,m,t;
	scanf("%d%d",&n,&m);
	for(int i = 0; i < n; i++)
		for(int j = 0; j < m; j++)
		{
			scanf("%d",&t);
			person[leng].group = i;
			person[leng].ability = t;
			leng++;
		}

	MergeSort(person, 0, leng-1);

	for(int i = 0; i < n; i++)
		cnt[i] = 0;

	int num_group = 0;
	int l = 0, r = 0;
	int _min = 1000000005;

	while(r < n*m)
	{
		int pos = person[r].group;
		if(num_group < n)
		{
			if(cnt[pos] == 0) num_group++;
			cnt[pos]++;
			r++;
		}
		else
		{
			while(num_group >= n)
			{
				int t = person[l].group;
				cnt[t]--;
				if(cnt[t] == 0) num_group--;
				l++;
			}
			int temp = person[r-1].ability - person[l-1].ability;
			if(temp < _min) _min = temp;
		}
	}
	printf("%d\n",_min);
	return 0;
}

SPOJ.COM - Thuật toán bài LABYR1 - Labyrinth

admin@phamvanlam.com — Mon, 07 Nov 2016 22:39:00 GMT

Đề bài:

Phía bắc của kim tự tháp chứa một mê cung rất lớn và phức tạp. Mê cung được chia thành những khối hình vuông, mỗi phần trong chúng được phủ bởi đá hoặc để trống. Có những cái móc nhỏ ở giữa mỗi khu vực trống. ACM phát hiện ra rằng 2 cái móc phải được kết nối với nhau bằng dây thừng, chạy xuyên qua những cái móc ở mỗi khu trống, trên đường nối giữa những cái được kết nối với nhau. Khi những cái thừng được gắn chặt thì một cánh cửa bí mật sẽ được mở ra. Vấn đề đặt ra là chúng ta không biết những cái móc nào để kết nối. Điều đó cũng có nghĩa là độ dài cần thiết của dây thừng cũng không biết. Nhiệm vụ của bạn là tìm ra độ dài lớn nhất có thể của dây cần thiết.

Đầu vào

Dòng đầu tiên là số T - số lượng test case. Mỗi test case bao gồm 2 số C và R (3 <= C,R <= 1000) là số cột và số hàng. Sau đó là R dòng, mỗi dòng bao gồm C kí tự. Những kí tự này xác định ra mê cung. Mỗi cái trong chúng là '#' hoặc '.'. Trong đó, ## miêu tả đá, còn dấu . miêu tả khu vực trống. Biết rằng chỉ có thể di chuyển giữa những khu vực kề nhau (khu vực kề nhau là khu vực có cạnh chung). Không thể di chuyển chéo và cũng không thể đi ra ngoài mê cung.

Mê cung được thiết kế sao cho chỉ có chính xác 1 đường giữa 2 khu vực trống. Do đó, nếu như tìm thấy những cái móc thích hợp thì rất dễ để tìm ra đường đúng để nối chúng.

Đầu ra

Mỗi test case in ra trên 1 dòng duy nhất, theo dạng sau:

Maximum rope length is X.

Trong đó, x là độ dài đường dài nhất giữa 2 khu vực trống.

Ví dụ

Đầu vào:

2
3 3
###
#.#
###
7 6
#######
#.#.###
#.#.###
#.#.#.#
#.....#
#######

Đầu ra:

Maximum rope length is 0.
Maximum rope length is 8.

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/LABYR1/

Phân tích

Bài toán sử dụng thuật toán tìm kiếm theo chiều rộng BFS để giải quyết. Cụ thể là mình sẽ áp dụng 2 lần BFS.
Lần thứ nhất mình sử dụng BFS tại một điểm bất kì. Từ đó tìm ra được điểm có khoảng cách xa nhất so với điểm bắt đầu.
Tiếp tục sử dụng thuật toán BFS tại điểm vừa tìm được. Mình lại tìm được điểm có khoảng cách xa nhất so với điểm bắt đầu trong trường hợp thứ hai này. Lần này, khoảng cách xa nhất chính là cái cần tìm.
Thực chất đây là thuật toán tìm đường đi dài nhất trên cây.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 1005;
const int MAX_QUEUE = MAX*MAX;

int C, R, T, Answer, SR, SC;
int Matrix[MAX][MAX], Mark[MAX][MAX];

typedef struct
{
	int row;
	int col;
}Point;

Point queue[MAX_QUEUE];
int fr, re, leng;

void Enqueue(int row, int col)
{
	Point p;
	p.row = row;
	p.col = col;

	queue[re] = p;
	re = (re + 1) % MAX_QUEUE;
	leng++;
}

Point Dequeue()
{
	Point p = queue[fr];
	fr = (fr + 1) % MAX_QUEUE;
	leng--;
	return p;
}

int drow[] = {-1,0,1, 0};
int dcol[] = { 0,1,0,-1};

// BFS tại điểm (row, col) tới tất cả các điểm còn lại
void BFS(int row, int col)
{
	for(int i = 0; i < R; i++)
		for(int j = 0; j < C; j++)
			Mark[i][j] = 0;

	fr = re = leng = 0;
	Enqueue(row, col);
	Mark[row][col] = 1;

	while(leng > 0)
	{
		Point p = Dequeue();
		for(int i = 0; i < 4; i++)
		{
			int r = p.row + drow[i];
			int c = p.col + dcol[i];
			if(r >= 0 && r < R && c >= 0 && c < C &&
				Mark[r][c] == 0 && Matrix[r][c] == 1)
			{
				Mark[r][c] = Mark[p.row][p.col] + 1;
				Enqueue(r,c);
			}
		}
	}
}

// Tìm điểm có khoảng cách xa nhất so với điểm xét ban đầu.
void FindMax()
{
	for(int i = 0; i < R; i++)
		for(int j = 0; j < C; j++)
			if(Mark[i][j] > Answer)
			{
				Answer = Mark[i][j];
				SR = i;
				SC = j;
			}
}

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);

	cin >> T;
	for(int tc = 0; tc < T; tc++)
	{
		Answer = SR = SC = 0;
		cin >> C >> R;
		for(int i = 0; i < R; i++)
		{
			char temp[MAX];
			cin >> temp;
			for(int j = 0; j < C; j++)
			{
				if(temp[j] == '#') Matrix[i][j] = 0;
				else if(temp[j] == '.')
				{
					Matrix[i][j] = 1;
					SR = i;
					SC = j;
				}
			}
		}

		BFS(SR,SC);
		FindMax();

		BFS(SR,SC);
		FindMax();

		cout << "Maximum rope length is " << Answer - 1 << "." << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài LASTDIG - The last digit

admin@phamvanlam.com — Sun, 06 Nov 2016 16:06:00 GMT

Đề bài:

Nestor đã làm công việc của lớp toán khoảng 3 ngày rồi. Tuy nhiên, anh ấy rất mệt vì phải làm rất nhiều công việc. Do đó, anh ấy nên chuyển giao công việc vào ngày mai. Giáo viên toán đưa cho anh ta 2 số a và b.

Bài toàn đặt ra là tìm ra chữ số cuối cùng của phép toán a^b (a mũ b). Hãy giúp anh ấy bài toán này. Bạn được đưa cho 2 số nguyên là a (0 <= a <= 20) và b (0 <= b <= 2,147,483,000), với a và b không được cùng bằng 0.

Đầu vào

Dòng đầu tiên là số nguyên t, số lượng test case, t <= 30. Sau đó là t test case, mỗi cái sẽ trên một dòng và bao gồm 2 số nguyên a, b cách nhau bằng dấu cách.

Đầu ra

Mỗi test case in ra trên 1 dòng là số cần tìm.

Ví dụ

Đầu vào:

2
3 10
6 2

Đầu ra:

9
6

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/LASTDIG/

Phân tích

Mình sẽ sử dụng thuật toán tham lam Greedy để giải bài toán.
Vì đề bài yêu cầu tìm chữ số cuối cùng nên thực chất mình chỉ cần quan tâm đến chữ số hàng đơn vị của số a, giả sử là x. Tức là nếu cần tìm chữ số cuối cùng của 13^b thì mình sẽ tìm chữ số cuối cùng của 3^b. Kết quả là giống nhau.
Tiếp theo, mình sẽ xử lý số b. Số b có giá trị lớn nhất là 2,147,483,000, nên mình không thể tính trực tiếp được. Tuy nhiên nếu bạn chịu khó viết ra lũy thừa của các số từ 1 đến 9. Bạn sẽ thấy rằng chữ số cuối cùng của kết quả sẽ lặp lại với chu kì bằng 4. Nghĩa là chữ số cuối cùng của a^b = chữ số cuối cùng của a^(b + 4). Do đó, thực chất mình chỉ cần lấy số dư của b cho 4, giả sử là y.
Vậy chữ số cuối cùng của a^b sẽ bằng chữ số cuối cùng của x^y. Cụ thể mời bạn theo dõi code bên dưới.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int power(int a, int b)
{
	if (b == 0) return 1;

	if(b % 2 == 0)
	{
		int t = power(a, b/2);
		return t*t;
	}
	else
	{
		int t = power(a, (b - 1) / 2);
		return t*t*a;
	}
}

int main()
{
	ios::sync_with_stdio(false);
	freopen("input.txt","r",stdin);

	int T;
	unsigned int a, b;
	int last_digit;

	cin >> T;
	for(int tc = 0; tc < T; tc++)
	{
		cin >> a >> b;
		if(b == 0) last_digit = 1;
		else
		{
			int x = a % 10;
			int y = b % 4;
			if (y == 0) y = 4;

			last_digit = power(x, y) % 10;
		}
		cout << last_digit << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài MICEMAZE - Mice and Maze

admin@phamvanlam.com — Sun, 06 Nov 2016 15:29:00 GMT

Đề bài:

Một tập hợp những con chuột thí nghiệm đang được huấn luyện để thoát khỏi mê cung. Mê cung được tạo bởi những ô, mà mỗi ô được kết nối tới những ô khác. Tuy nhiên, sẽ có những vật cản trên đường đi giữa các ô. Vì vậy, sẽ cần thêm thời gian để vượt qua những vật cản này. Một vài đường chỉ cho phép con chuột đi theo một chiều và không có đường vòng.

Giả sử là tất cả lũ chuột đã được huấn luyện, khi được đặt ở một ô bất kì trên mê cung, tìm đường để đưa chúng ra khỏi mê cung với thời gian ngắn nhất.

Chúng ta sẽ làm một thí nghiệm như sau: mỗi một con chuột được đặt vào một ô trên mê cung và một đồng hồ đếm ngược được bắt đầu. Khi đồng hồ dừng lại, đếm số chuột thoát ra được mê cung.

Vấn đề:

Viết một chương trình, cho trước thông tin của những con chuột và thời gian giới hạn. Dự đoán số chuột thoát ra được khỏi mê cung. Giả sử rằng sẽ không có nút thắt cổ chai nào trên mê cung, tất cả các ô sẽ có đủ khoảng trống để chứa số lượng chuột ngẫu nhiên.

Đầu vào

Các ô trong mê cung được đánh số từ 1 đến N, trong đó N là số lượng ô, N <= 100. Ba dòng đầu tiên chứa số N - số lượng ô, E - chỉ số của ô lối thoát và giá trị T là thời gian bắt đầu của đồng hồ đếm ngược.

Dòng thứ 4 là số M - số lượng kết nối trong mê cung. Sau đó là M dòng. Mỗi dòng xác định 1 kết nối, bao gồm 3 số là số a, b và c. Trong đó a, b là chỉ số của các ô (a, b thuộc từ 1 đến N), và c là thời gian cần để đi từ a đến b.

Chú ý rằng mỗi kết nối là một chiều, tức là con chuột không thể đi từ b về a trừ khi có kết nối từ b đến a. Cũng chú ý là, thời gian di chuyển trên mỗi hướng là khác nhau.

Đầu ra

Mỗi test case in ra trên một dòng, là số lượng chuột đến được ô thoát Exit của mê cung trong thời gian T.

Ví dụ

Đầu vào:

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/MICEMAZE/

Phân tích

Theo suy luận thông thường, mình sẽ phải xét mỗi con chuột, tìm đường đi ngắn nhất của nó đến ô thoát. Kiểm tra xem thời gian đó có nhỏ hơn hoặc bằng thời gian giới hạn T hay không. Nếu thỏa mãn thì con chuột đó sẽ thoát được khỏi mê cung trong thời gian cho phép. Tuy nhiên, nếu xét riêng từng con như vậy, chắc chắn sẽ bị time limit.

Bài toán ở đây là tìm đường đi ngắn nhất từ N điểm đến 1 điểm. Thực chất, mình sẽ quy về bài toán tìm đường đi ngắn nhất từ 1 điểm đến N điểm. Bằng cách đảo ngược lại chiều của các đường đi.

Để tìm đường đi ngắn nhất từ một điểm đến N điểm, mình sử dụng thuật toán Dijkstra

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX_INT = 1 << 20;
const int MAX = 105;

int N, M, E, T;
int Matrix[MAX][MAX];
int Mark[MAX], Value[MAX];

int FindIdMinValue()
{
	int idm = 0, _min = MAX_INT;
	for(int i = 1; i <= N; i++)
		if(Mark[i] == 0 && Value[i] < _min)
		{
			_min = Value[i];
			idm  = i;
		}
	return idm;
}

void Dijkstra(int start)
{
	int cnt = 0;
	for(int i = 1; i <= N; i++)
	{
		Mark[i] = 0;
		Value[i] = MAX_INT;
	}

	Value[start] = 0;
	while(cnt < N)
	{
		int idmin = FindIdMinValue();
		Mark[idmin] = 1;
		cnt++;
		for(int i = 1; i <= N; i++)
			if(Mark[i] == 0 && Matrix[idmin][i] > 0 &&
				Value[idmin] + Matrix[idmin][i] < Value[i])
				Value[i] = Value[idmin] + Matrix[idmin][i];
	}
}

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);

	cin >> N >> E >> T >> M;
	for(int i = 1; i <= N; i++)
		for(int j = 1; j <= N; j++)
			Matrix[i][j] = 0;

	int a, b, t;
	for(int i = 0; i < M; i++)
	{
		cin >> a >> b >> t;
		Matrix[b][a] = t;
	}

	// implementing code
	Dijkstra(E);

	// Đếm những ô có giá trị <= T
	// là những ô con chuột có thể thoát.
	int Answer = 0;
	for(int i = 1; i <= N; i++)
		if(Value[i] <= T) Answer++;

	// output
	cout << Answer << endl;
	return 0;
}

SPOJ.COM - Thuật toán bài MKEQUAL - Make them equal !

admin@phamvanlam.com — Sun, 06 Nov 2016 14:48:00 GMT

Đề bài:

Bạn có một dãy gồm N phần tử. Tại bất kì lượt di chuyển nào, bạn chọn ra 2 chỉ số i và j ( 0 <= i, j < N và i != j ) và tăng giá trị tại một chỉ số và giảm giá trị tại chỉ số còn lại. Bạn có thể thực hiện lần di chuyển này với số lần bất kì. Hỏi số phần tử lớn nhất có thể mà chúng có giá trị bằng nhau (sau bất kì số lần di chuyển nào).

Đầu vào

Đầu vào bao gồm số T là số lượng test case, 1 <= T <= 100. Sau đó là T test case, mỗi cái bao gồm số N - là số lượng phần tử của mảng ở dòng đầu tiên 1 <= N <= 100000. Dòng tiếp theo chứa N số nguyên được phân cách bởi dấu cách, có giá trị từ 0 đến 100000.

Đầu ra

Mỗi test case in ra trên một dòng giá trị cần tìm.

Ví dụ

Đầu vào:

1
4
1 2 3 4

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/MKEQUAL/

Phân tích

Mình sử dụng thuật toán tham lam Greedy để giải quyết bài toán.

Mình có nhận xét là nếu như tổng của N số đó (Sum) mà chia hết cho N thì chắc chắn sẽ có cách để chuyển hết N số đó về số có giá trị (Sum / N). Do đó kết quả sẽ là N.

Ngược lại. mình có thể chuyển N số đó thành N - 1 số có giá trị (Sum / N) và số còn lại có giá trị tùy ý. Kết quả là N - 1.

Ví dụ 1: mình có dãy N = 4 số: 3 5 6 10

Tổng là Sum = 3 + 5 + 6 + 10 = 24 => Sum / N = 24 / 4 = 6. Do đó mình sẽ chuyển được hết 4 số này về giá trị = 6, bằng cách:

Tăng 3 và giảm 10: sau 3 lần mình được dãy: 6 5 6 7
Tăng 5 và giảm 7: sau 1 lần mình đưa được về dãy: 6 6 6 6

Vậy kết quả = N = 4

Ví dụ 2: dãy N = 4 số: 1 2 3 4

Tổng là Sum = 1 + 2 + 3 + 4 = 10 => Sum / N = 10 / 4 = 2 (chia nguyên). Do đó mình sẽ chuyển được 4 số này về dạng là có 3 số = 2 và số còn lại có giá trị khác 2.

Tăng 1, giảm 3: sau một lần mình đã có dãy: 2 2 2 4.

Vậy kết quả = N - 1 = 3

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);
	int Testcase, n, sum;

	cin >> Testcase;
	for(int tc = 0; tc < Testcase; tc++)
	{
		cin >> n;
		sum = 0;
		for(int i = 0; i < n; i++)
		{
			int temp;
			cin >> temp;
			sum += temp;
		}
		if(sum % n == 0) cout << n << endl;
		else cout << n - 1 << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài MKJUMPS - Making Jumps

admin@phamvanlam.com — Sun, 06 Nov 2016 14:21:00 GMT

Đề bài:

Quân mã là một quân cờ được sử dụng trong trò chơi đánh cờ. Bàn cờ là một mảng gồm những phần tử hình vuông. Mỗi khi quân mã di chuyển. Vị trí di chuyển đến là hai hàng và một cột hay hai cột và một hàng tính từ vị trí xuất phát. Vì vậy, một con mã bắt đầu từ vị trí hàng r, cột c - được kí hiệu là (r, c), có thể di chuyển đến các vị trí (r-2,c-1), (r-2,c+1), (r-1,c-2), (r-1,c+2), (r+1,c-2), (r+1,c+2), (r+2,c-1) hoặc (r+2,c+1). Dĩ nhiên con mã sẽ không thể di chuyển tới vị trí không nằm trên bàn cờ.

Giả sử bàn cờ không phải hình vuông, nhưng thay vào đó là có những hàng, với số lượng cột ở bên phải của phần tử đầu tiên. Hỏi có bao nhiêu vị trí mà với vị trí ban đầu của con mã là ở trên cùng bên trái - đánh dấu *, sẽ không bao giờ đi tới với bất kì số lần di chuyển nào, với điều kiện không được nghỉ trên một ô nào nhiều hơn một lần.

Nếu cần thiết, quân mã không được phép di chuyển tới những vùng nằm ngoài của bàn cờ mà nó chỉ đi được tới những ô bên trong bàn cờ.

Đầu vào

Có nhiều test case. Mỗi test case bắt đầu với số nguyên n, trong khoảng từ 1 đến 10 - xác định số lượng hàng. Sau đó là n cặp số nguyên, mỗi cặp tương ứng với một hàng. Trong đó, số nguyên đầu tiên xác định số ô vuông bị bỏ qua ở đầu của hàng và số nguyên thứ hai là số ô vuông của hàng đó. Test case cuối cùng theo sau bởi số 0.

Ví dụ cho trường hợp ở hình vẽ trên:

7 0 3 0 3 0 4 0 4 1 3 1 7 4 4

Số hàng, số cột tối đa là 10. Do đó mọi cấu hình của bàn cờ sẽ đều phải nằm trong hình vuông 10x10.

Đầu ra

Với mỗi đầu ra, in ra chỉ số test case, và số lượng hình vuông không được thăm theo ví dụ mẫu sau đây.

Ví dụ

Đầu vào:

7 0 3 0 3 0 4 0 4 1 3 1 7 4 4
3 0 3 0 3 0 3
2 0 1 2 1
0

Đầu ra:

Case 1, 4 squares can not be reached.
Case 2, 1 square can not be reached.
Case 3, 0 squares can not be reached.

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/MKJUMPS/

Phân tích

Bài toán này mình sẽ sử dụng thuật toán quay lui có điều kiện Backtracking để duyệt hết tất cả các cách đi. Với chú ý đó là quân mã có thể đi 8 cách khác nhau tính từ 1 ô. Và mỗi ô chỉ được đi qua một lần.
Một chú ý khi in ra kết quả. Đó là nếu chỉ có một ô không được đi qua thì in "...square..." (số ít), còn lại thì phải in "...squares..." (số nhiều).

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int n;              // Số hàng
int Answer;         // Đáp án
int sum;            // Tổng số lượng ô của bàn cờ
int Matrix[10][10]; // Lưu bàn cờ
int SR, SC;         // Tọa độ vị trí đầu tiên.

int drow[8] = {-2,-1,1,2, 2, 1,-1,-2};
int dcol[8] = { 1, 2,2,1,-1,-2,-2,-1};

void Start(int row, int col, int cnt)
{
	for(int i = 0; i < 8; i++)
	{
		int r = row + drow[i];
		int c = col + dcol[i];

		// Chỉ xét những ô thuộc bàn cờ và chưa được thăm
		// vì mỗi ô chỉ được đi qua một lần
		if(r >= 0 && r < n && c >= 0 && c < 10 && Matrix[r][c] == 1)
		{
			Matrix[r][c] = 2;
			Start(r, c, cnt+1);
			Matrix[r][c] = 1;
		}
	}

	// Cập nhật số lượng ô đi qua nhiều nhất
	if(cnt > Answer) Answer = cnt;
}

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);
	int tc = 0;
	while(true)
	{
		cin >> n;
		if(n == 0) break;

		tc++;
		Answer = sum = 0;
		for(int i = 0; i < 10; i++)
			for(int j = 0; j < 10; j++)
				Matrix[i][j] = 0;

		int zero, number;
		for(int i = 0; i < n; i++)
		{
			cin >> zero >> number;
			sum += number;

			// Lấy ra tọa độ ô đầu tiên
			if(i == 0)
			{
				SR = 0;
				SC = zero;
			}

			// Đánh dấu những ô thuộc bàn cờ là 1
			for(int j = 0; j < number; j++)
				Matrix[i][j + zero] = 1;
		}

		// Những ô đã đi qua đánh dấu là 2
		Matrix[SR][SC] = 2;
		Start(SR, SC, 1);

		Answer = sum - Answer;

		// output
		cout << "Case " << tc << ", " << Answer ;
		if (Answer == 1)  cout << " square can not be reached." << endl;
		else cout << " squares can not be reached." << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài MSUBSTR - Mirror Strings !!!

admin@phamvanlam.com — Sun, 06 Nov 2016 11:31:00 GMT

Đề bài:

Như chúng ta đã biết Utkarsh rất giỏi giải quyết những bài toán liên quan đến số. Lần này, Arpit đã suy nghĩ một cách khôn ngoan và đã đưa cho Utkarsh một bài toán liên quan đến xâu (string). Arpit đã đưa cho Utkarsh một xâu kí tự và thách thức Utkarsh tìm ra xâu con (substring) dài nhất mà xâu phản chiếu (mirror string) giống với nó, và số lượng những substring này. Bây giờ, Utkarsh rất bận nên anh ấy nhờ bạn giúp đỡ giải quyết bài toán này.

Ví dụ về mirror string: cho xâu "lalit" thì xâu phản chiếu là "tilal".

Đầu vào

Có T test case, t <= 200. Sau đó là T dòng, mỗi dòng chứa những kí tự viết thường từ a-z có độ dài l (1 <= l <= 3000)

Đầu ra

Mỗi test case được in ra trên 1 dòng, bao gồm 2 số nguyên lần lượt là độ dài substring dài nhất thỏa mãn, và số lượng substring loại này.

Ví dụ

Đầu vào:

3 
lalit 
abedcdetr 
abcde

Đầu ra:

3 1 5 1 1 5

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/MSUBSTR/

Phân tích

Bài này sử dụng thuật toán tham lam Greedy để giải quyết.
Vì đề bài yêu cầu tìm ra substring có độ dài dài nhất thỏa mãn là mirror string, nên mình sẽ kiểm tra tất cả những substring có độ dài bằng độ dài của string ban đầu trước, sau đó giảm dần một đơn vị.
Cứ kiểm tra như vậy cho đến khi gặp substring nào thỏa mãn, thì đó là substring dài nhất. Tiếp tục với độ dài substring như vậy để đếm số lượng substring thỏa mãn. Sau đó, thoát luôn mà không cần phải xét tiếp với những độ dài nhỏ hơn.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 3005;

int GetLength(char *str)
{
	int length = 0;
	while(str[length] != '\0') length++;
	return length;
}

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);
	int T, length, len_sub, numAnswer;
	char str[MAX];
	bool finish;

	cin >> T;
	for(int tc = 0; tc < T; tc++)
	{
		cin >> str;
		length		= GetLength(str);
		len_sub		= length;
		while(true)
		{
			numAnswer = 0;
			finish = false;
			for(int i = 0; i < length; i++)
			{
				if(i + len_sub > length) break;
				if(len_sub == 1 || (len_sub == 2 && str[i] == str[i+1]))
				{
					numAnswer++;
					finish = true;
				}
				else
				{
					bool check = true;
					for(int j = 0; j <= (len_sub - 1)/2; j++)
						if(str[j + i] != str[len_sub - 1 - j + i])
						{
							check = false;
							break;
						}

					if (check == true)
					{
						numAnswer++;
						finish = true;
					}
				}
			}
			if (finish == true) break;
			if (len_sub == 1) break;
			len_sub--;
		}
		cout << len_sub << " " << numAnswer << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài NSTEPS - Number Steps

admin@phamvanlam.com — Sun, 06 Nov 2016 10:58:00 GMT

Đề bài:

Bắt đầu từ điểm có tọa độ (0,0) trên mặt phẳng. Chúng mình đã viết sẵn những số nguyên không âm 0, 1, 2,.. như hình dưới. Ví dụ: 1, 2, 3 lần lượt được viết ở các điểm (1, 1), (2,0) và (3,1), và cách viết này sẽ được tiếp tục.

Bạn hãy viết một chương trình đọc vào tọa độ (x, y) và viết ra số tương ứng với tọa độ đó (nếu có). Biết giá trị của tọa độ x, y đều thuộc từ 0 đến 10000.

Đầu vào

Dòng đầu tiên của đầu vào là số N - số lượng test case. N dòng tiếp theo, mỗi dòng sẽ gồm 2 số tương ứng là tọa độ x, y của một điểm.

Đầu ra

Với mỗi test case, in ra trên một dòng một số là số tương ứng với tọa độ đó nếu có. Ngược lại thì in ra No Number.

Ví dụ

Đầu vào:

Đầu ra:

6
12
No Number

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/NSTEPS/

Phân tích

Bài này sử dụng thuật toán tham lam Greedy để giải quyết.
Trước tiên, bạn có thể thấy rằng các số sẽ nằm trên 2 đường thẳng có phương trình là y = x và y = x - 2. Do đó, khi đọc vào một điểm (x, y), nếu như điểm đó không thuộc một trong hai đường trên thì có nghĩa là sẽ không có số. Ngược lại, chắc chắn sẽ có số.
Tiếp theo, vì các điểm thuộc 2 phương trình y = x và y = x - 2 nên tọa độ của chúng sẽ cùng chẵn hoặc cùng lẻ. Hơn nữa, mình phát hiện ra một quy luật đó là:
- Nếu x, y chẵn thì giá trị số = x + y.
- Nếu x, y lẻ thì giá trị số = x + y - 1.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int CheckValid(int x, int y)
{
	if (x >= y && x - y <= 2)
	{
		if (x%2 == 0 && y%2 == 0) return x + y;
		if (x%2 == 1 && y%2 == 1) return x + y -1;
	}
	return -1;
}

int main()
{
	//freopen("input.txt","r", stdin);
	int N, x, y;
	cin >> N;
	for(int tc = 0; tc < N; tc++)
	{
		cin >> x >> y;
		int ch = CheckValid(x,y);

		if ( ch == -1) cout << "No Number" << endl;
		else cout << ch << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài NUMPATH - Gutibazi

admin@phamvanlam.com — Sat, 05 Nov 2016 22:35:00 GMT

Đề bài:

Xunayed rất là mạnh mẽ. Anh ấy đã phát hiện ra rằng bạn của anh ta là Nurulla - người giống với anh trai mình, đã làm một việc không có khí phách với anh ta. Xunayed có thể tha thứ bất cứ điều gì, nhưng việc làm điều không có khí phách với anh ta là không thể tha thứ được. Nhưng để dạy cho Nurulla một bài học, Xunayed đầu tiên phải đến chỗ Nurulla qua một vài đường. Vì vậy, vấn đề xảy ra ở đây là những con đường thuộc về một người rất quyền lực tên là Rizvi và tất cả mọi người phải xin phép người này để có thể đi qua được những con đường. Rizvi sẽ cho phép Xunayed nếu như Xunayed giải quyết được một điều bí ẩn.

Đường đi là một vài lưới 2 chiều. Xunayed hiện tại đang đứng ở vị trí ô trên cùng bên trái (1, 1) - là điểm bắt đầu. Nurulla đang đứng ở ô dưới cùng bên phải - là điểm đích. Biết Xunayed chỉ có thể đi xuống, hay sang phải. Hỏi có bao nhiêu đường mà Xunayed có thể tiếp cận Nurulla.

Hãy giải quyết bài toán này để giúp Xunayed đòi lại quyền công bằng.

Đầu vào

Bắt đầu với số nguyên T (T <= 50) là số lượng test case. Mỗi test case sẽ gồm một dòng chứa 2 số nguyên R, C (1 <= R, C <= 7), trong đó, R là số lượng hàng, C là số lượng cột.

Đầu ra

Với mỗi test case, in ra số nguyên là số đường mà Xunayed có thể tiếp cận Nurulla.

Ví dụ

Đầu vào:

2
1 1
2 2

Đầu ra:

1
2

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/NUMPATH/

Phân tích

Bài toán này mình sẽ dùng thuật toán vét cạn Brute force, được triển khai bằng đệ quy để duyệt hết tất cả các trường hợp. Điểm bắt đầu là (0, 0) và điểm đích là (R-1,C-1). Tại mỗi điểm chỉ có thể đi xuống, hoặc sang bên phải.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

int R, C;
int Matrix[7][7];
int Num_path;

void Visit(int row, int col)
{
	// Nếu đi được đến điểm đích thì tăng số đường lên 1
	if(row == R-1 && col == C-1) Num_path++;
	else
	{
		// Nếu sang bên phải
		if(row + 1 <= R-1) Visit(row + 1,col);

		// Nếu đi xuống dưới
		if(col + 1 <= C-1) Visit(row,col + 1);
	}
}

int main()
{
	int Testcase;
	cin >> Testcase;
	for(int tc = 0; tc < Testcase; tc++)
	{
		cin >> R >> C;
		Num_path = 0;

		Visit(0, 0);
		cout << Num_path << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài ONP - Transform the Expression

admin@phamvanlam.com — Sat, 05 Nov 2016 22:07:00 GMT

Đề bài:

Biến đổi biểu thức đại số sau thành dạng "kí pháp nghịch đảo Ba Lan" (RPN : Reverse Polish Notation). Hay nói cách khác là biến đổi biểu thức từ dạng trung tố thành dạng hậu tố. Trong đó, các toán tử hai ngôi: +, -, , /, ^ (có độ ưu tiên từ thấp nhất lên cao nhất), dấu ngoặc (), toán hạng chỉ bao gồm chữ cái a, b, c,...z. Giả sử rằng chỉ có một dạng RPN, không có trường hợp kiểu như ab*c.

Đầu vào

T [số lượng biểu thức <= 100]

Biểu thức [độ dài <= 400]

[Những biểu thức khác] Thành phần ở trong dấu [] không xuất hiện ở đầu vào.

Đầu ra

Các biểu thức dạng RPN, mỗi cái trên một dòng.

Ví dụ

Đầu vào:

3
(a+(b*c))
((a+b)*(z+x))
((a+t)*((b+(a+c))^(c+d)))

Đầu ra:

abc*+
ab+zx+*
at+bac++cd+^*

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/ONP/

Phân tích

Đây là bài toán cơ bản, có thể xếp vào bài toán sử dụng thuật toán tham lam Greedy.
Thuật toán biến đổi biểu thức trung tố thành dạng hậu tố sử dụng Stack là:
- Nếu là toán hạng: cho ra output.
- Nếu là dấu mở ngoặc "(": cho vào stack
- Nếu là dấu đóng ngoặc ")": lấy các toán tử trong stack ra và cho vào output cho đến khi gặp dấu mở ngoặc "(". (Dấu mở ngoặc cũng phải được đưa ra khỏi stack)
- Nếu là toán tử:
  - Chừng nào ở đỉnh stack là toán tử và toán tử đó có độ ưu tiên lớn hơn hoặc bằng toán tử hiện tại thì lấy toán tử đó ra khỏi stack và cho ra output.
  - Đưa toán tử hiện tại vào stack Sau khi duyệt hết biểu thức trung tố, nếu trong stack còn phần tử thì lấy các thành phần trong đó ra và cho lần lượt vào output. (Tham khảo tại: YinYang's Programming Blog)

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 405;

// Trả về true nếu kí tự ch là toán hạng
bool IsOperand(char ch)
{
	return (ch >= 'a' && ch <= 'z');
}

// Trả về true nếu kí tự ch là toán tử
bool IsOperator(char ch)
{
	if(ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '^') return true;
	return false;
}

// Trả về độ ưu tiên cho các toán tử
int GetPriority(char ch)
{
	if(ch == '+') return 1;
	if(ch == '-') return 2;
	if(ch == '*') return 3;
	if(ch == '/') return 4;
	if(ch == '^') return 5;
	return -1;
}

// Trả về độ dài xâu str
int GetLength(char *str)
{
	int length = 0;
	while(str[length] != '\0') length++;
	return length;
}

int main()
{
	ios::sync_with_stdio(false);
	freopen("input.txt","r",stdin);

	int T = 0;
	char str[MAX];

	cin >> T;
	for(int tc = 0; tc < T; tc++)
	{
		cin >> str;
		int length = GetLength(str);

		char *stack = new char[length + 1];
		int st_size = 0;

		// Thực hiện theo thuật toán
		for(int i = 0; i < length; i++)
		{
			if(IsOperand(str[i]))
			{
				cout << str[i];
			}
			else if(str[i] == '(')
			{
				stack[st_size++] = str[i];
			}
			else if(str[i] == ')')
			{
				while (stack[st_size-1] != '(')
				{
					cout << stack[st_size-1];
					st_size--;
				}
				st_size--;
			}
			else if(IsOperator(str[i]))
			{
				while(IsOperator(stack[st_size-1]) &&
				        (GetPriority(stack[st_size-1]) >= GetPriority(str[i])))
				{
					cout << stack[st_size-1];
					st_size--;
				}

				stack[st_size] = str[i];
				st_size++;
			}
		}
		cout << endl;
		delete[] stack;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài PQUEUE - Printer Queue

admin@phamvanlam.com — Sat, 05 Nov 2016 21:38:00 GMT

Đề bài:

Chỉ có một cái máy in duy nhất và nó đang phải làm việc rất nhiều. Thỉnh thoảng có hàng trăm công việc ở hàng đợi của máy in. Và bạn phải đợi hàng giờ đồng hồ chỉ để in một trang giấy.

Bởi vì một số công việc là quan trọng hơn những cái khác, nên Hacker General đã phát minh ra một hệ thống hàng đợi ưu tiên cho máy in. Bây giờ, mỗi công việc sẽ được gán một giá trị độ ưu tiên từ 1 đến 9. Trong đó, 9 là độ ưu tiên cao nhất và 1 là độ ưu tiên thấp nhất. Máy in làm việc theo nguyên lý sau:

Công việc j đầu tiên được lấy từ hàng đợi
Nếu có công việc nào mà độ ưu tiên cao hơn công việc j thì cho j xuống cuối của hàng đợi và không in nó.
Ngược lại, in công việc j (không cho nó xuống cuối cùng của hàng đợi)

Theo cách này, công việc in trở nên rất nhanh. Dĩ nhiên, sẽ có những cái phải chờ đợi để được in. Nhưng đó chính là cuộc sống.

Vấn đề của bạn với chính sách mới này là rất khó để xác định xem khi nào thì công việc của bạn được in. Bạn quyết định viết một chương trình để xác định nó. Chương trình này được đưa cho trạng thái hiện tại của hàng đợi (danh sách của thứ tự ưu tiên), cũng như là vị trí công việc của bạn. Bạn phải tính được khi nào thì công việc của bạn được hoàn thành. Giả sử rằng sẽ không có công việc nào nữa được cho vào máy in. Để cho đơn giản, giả sử việc in một công việc mất 1 phút để hoàn thành. Việc cho vào hay lấy ra từ hàng đợi xảy ra tức thời.

Đầu vào

Dòng đầu tiên là số nguyên t, t <= 100, là số lượng test case. Mỗi test case sẽ bao gồm 2 số nguyên n và m. Trong đó, n là số lượng công việc và m là vị trí công việc của bạn (1 ≤ n ≤ 100, 0 ≤ m ≤ n-1). Vị trí công việc đầu tiên là 0, công việc thứ 2 là 1,... Dòng tiếp theo là n số nguyên, thuộc từ 1 đến 9, cho biết độ ưu tiên của các công việc. Số đầu tiên là độ ưu tiên của công việc thứ nhất, số tiếp theo là độ ưu tiên của công việc thứ 2,...

Đầu ra

Với mỗi một test case, in ra trên 1 dòng, chứa 1 số là số phút cần phải đợi cho đến khi công việc của bạn được hoàn thành. Giả sử không có công việc nào được thêm vào máy in.

Ví dụ

Đầu vào:

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

Đầu ra:

1
2
5

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/PQUEUE/

Phân tích

Bài toán này hoàn toàn là việc sử dụng hàng đợi. Nên có thể xếp vào loạt bài sử dụng thuật toán tham lam Greedy.
Một chú ý ở đây là: để đánh dấu vị trí công việc cần tìm thì mình sẽ chuyển giá trị của nó về âm. Nghĩa là nếu công việc cần tính có độ ưu tiên là 6, thì mình sẽ chuyển nó về -6. Như vậy, nếu muốn so sánh độ ưu tiên thì mình chỉ cần so sánh giá trị tuyệt đối của chúng.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 105;

int N, M;
int front, rear, leng, queue[MAX];
int numMinute;

int Abs(int a)
{
	if(a >= 0) return a;
	return -a;
}

void Enqueue(int p)
{
	queue[rear] = p;
	rear = (rear + 1) % MAX;
	leng++;
}

int Dequeue()
{
	int p = queue[front];
	front = (front + 1) % MAX;
	leng--;
	return p;
}

int main()
{
	freopen("input.txt","r",stdin);
	int T;
	cin >> T;
	for(int tc = 0; tc < T; tc++)
	{
		// Nhập đầu vào
		cin >> N >> M;
		for(int i = 0; i < N; i++)
			cin >> queue[i];

		// Đánh dấu vị trí công việc cần hoàn thành
		// bằng cách chuyển về giá trị âm
		queue[M] = -queue[M];

		front = 0;
		rear  = N;
		leng  = N;
		numMinute = 0;

		while(leng > 0)
		{
			int k = Dequeue();
			bool IsPrint = true;

			// Duyệt hàng đợi từ front đến rear
			for(int i = front; i != rear; i = (i+1) % MAX)
			{
				// Nếu tồn tại công việc có độ ưu tiên lớn hơn k
				// thì cho k xuống cuối hàng đợi
				if(Abs(k) < Abs(queue[i]))
				{
					IsPrint = false;
					Enqueue(k);
					break;
				}
			}

			// Ngược lại, nếu không tìm thấy, thì chứng tỏ k có độ ưu tiên cao nhất.
			if(IsPrint)
			{
				numMinute++;
				// Nếu k < 0 thì đó là công việc cần tìm
				if(k < 0)
				{
					cout << numMinute << endl;
					break;
				}
			}
		}
	}
	return 0;
}

SPOJ.COM - Thuật toán bài PRIME1 - Prime Generator

admin@phamvanlam.com — Sat, 05 Nov 2016 16:51:00 GMT

Đề bài:

Peter muốn tạo ra những số nguyên tố cho một hệ thống bí mật của anh ta. Hãy giúp Peter. Nhiệm vụ của bạn là tạo ra tất cả những số nguyên tố giữa hai số cho trước.

Đầu vào

Bắt đầu với số T là số lượng test case, t <= 10. Với mỗi test case, sẽ có một dòng bao gồm 2 số m và n, 1 <= m <= n <= 1000000000, n - m <= 100000, phân biệt nhau bởi dấu cách.

Đầu ra

Với mỗi test case, in ra tất cả những số nguyên tố p thỏa mãn m <= p <= n, mỗi số in ra trên một dòng. Mỗi test case phân biệt nhau bởi dòng trống.

Ví dụ

Đầu vào:

2
1 10
3 5

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/PRIME1/

Phân tích

Đây là một bài toán đơn giản, có thể xếp vào loạt bài sử dụng thuật toán tham lam Greedy. Đơn giản chỉ là việc duyệt các số từ số M đến số N, kiểm tra xem số nào là số nguyên tố thì in ra.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

bool isPrime(int a)
{
	if(a == 0 || a == 1) return false;
	if(a == 2) return true;

	for(int i = 2; i*i <= a; i++)
		if(a % i == 0)
			return false;

	return true;
}

int main()
{
	ios::sync_with_stdio(false);
	freopen("input.txt","r",stdin);

	int T, M, N;
	cin >> T;
	for(int tc = 0; tc < T; tc++)
	{
		cin >> M >> N;
		for(int i = M; i <= N; i++)
			if(isPrime(i)) cout << i << endl;
		cout << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài QKP - Queens, Knights and Pawns

admin@phamvanlam.com — Sat, 05 Nov 2016 16:06:00 GMT

Đề bài:

Tất cả bạn có thể đã quen thuộc với bài toán nổi tiếng 8 con hậu - bài toán yêu cầu bạn đặt 8 con hậu trên một bàn cờ sao cho không có 2 con nào có thể tấn công được nhau. Ở bài toán này, bạn được cho vị trí của quân hậu (Q), quân mã (K) và quân tốt (P) và yêu cầu bạn tìm ra xem có bao nhiêu ô trống mà không bị tấn công bởi con con mã hoặc con hậu hoặc cả hai. Chúng ta sẽ gọi những ô này là ô an toàn (safe). Ở đây, quân tốt được xem như là các vật cản mà không có khả năng tấn công. Bảng sau có 6 ô an toàn (là các ô tô đậm hơn)

Nhắc lại rằng, con mã chỉ có thể di chuyển tới bất kì một ô rảnh nào mà nó ở góc đối diện của hình chữ nhât kích thước 2x3. Con hậu có thể di chuyển theo 8 hướng. Chú ý rằng, con hậu có thể bị chặn bởi các con khác, trong khi con mã thì sẽ không bị chặn bởi con khác.

Đầu vào

Bao gồm nhiều test case. Mỗi test case sẽ bao gồm 4 dòng. Dòng đầu tiên bao gồm 2 số nguyên n, m - biểu diễn kích thước của bàn cờ, tương ứng với số hàng và số cột, n, m không quá 1000. 3 dòng tiếp theo sẽ có dạng như sau:

k r₁ c₁ r₂ c₂ · · · r_k c_k

xác định số lượng và vị trí của các con hậu, mã, và tốt. Chỉ số hàng, cột sẽ bắt đầu từ 1. Mỗi loại sẽ có tối đa 100 con. Giá trị n=m=0 xác định kết thúc đầu vào.

Đầu ra

Mỗi test case sẽ in ra dạng : Board b has s safe squares. Trong đó, b là chỉ số của bàn cờ, bắt đầu từ 1 và s là số ô an toàn tương ứng.

Ví dụ

Đầu vào:

Đầu ra:


Board 1 has 6 safe squares.
Board 2 has 0 safe squares.
Board 3 has 996998 safe squares.

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/QKP/

Phân tích

Ở đây mình sẽ sử dụng thuật toán tham lam Greedy để giải bài toán.

Với mỗi con mã, mình sẽ duyệt 8 hướng và đếm vị trí mỗi con mã có thể ăn. Sau khi tính xong thì mình sẽ đánh dấu rằng vị trí đó đã được ăn để không bị trùng lặp cho lần sau.
Sau khi duyệt xong hết con mã sẽ đến con hậu.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int Q         = 0;
const int K         = 1;
const int P         = 2;
const int Safe      = 3;
const int Unsafe    = 4;

int Board[1000][1000];	// Lưu bàn cờ
int ROW, COL;			// Số hàng ,cột

// Đường đi con mã
int K_row[8] = {-1,-2, 1, 2,-2,-1, 2, 1};
int K_col[8] = { 2, 1, 2, 1,-1,-2,-1,-2};

/*
* Tính số ô con mã có thể ăn
* @PARAM: row, hàng của con mã đang xét
* @PARAM: col, cột của con mã đang xét
* RETURN: số vị trí con mã có thể ăn
*/
int checkK(int row, int col)
{
	int count = 0;
	// Kiểm tra 8 hướng của con mã
	for(int i = 0; i < 8; i++)
	{
		int r = row + K_row[i];
		int c = col + K_col[i];
		if(r <= ROW && r >= 0 && c <= COL && c >= 0)
		{
			// Nếu ô nào đang ở vị trí an toàn
			// thì tức là con mã có thể ăn
			// cho ô đó thành Unsafe để tránh lặp và tăng biến đếm
			if(Board[r][c] == Safe)
			{
				Board[r][c] = Unsafe;
				count++;
			}
		}
	}
	return count;
}

// Đường đi con hậu
int Q_row[8] = { 0, 0, 1, 1, 1,-1,-1,-1};
int Q_col[8] = { 1,-1,-1, 0, 1,-1, 0, 1};
int Sum = 0;

/*
* Duyệt mỗi con hậu tại vị trí row, col theo từng hướng
* Sử dụng đệ quy
*/
void checkQ(int row, int col, int direct)
{
	int r = row + Q_row[direct];
	int c = col + Q_col[direct];

	if(r <= ROW && r >= 0 && c <= COL && c >= 0)
	{
		// Ô nào đang an toàn thì sẽ bị ăn
		// Cho thành Unsafe
		if(Board[r][c] == Safe)
		{
			Board[r][c] = Unsafe;
			Sum--;
			checkQ(r, c, direct);
		}
		else if(Board[r][c] == Unsafe)
		{
			// Trường hợp này là đã tính trước đó.
			checkQ(r,c,direct);
		}
	}
}

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);
	int tc = 0;
	while(true)
	{
		cin >> ROW >> COL;
		if(ROW == 0 && COL == 0) break;
		tc ++;
		Sum = ROW * COL;
		ROW--;
		COL--;

		// Ban đầu gán các ô là ô an toàn
		for(int r = 0; r <= ROW; r++)
			for(int c = 0; c <= COL; c++)
				Board[r][c] = Safe;

		int r, c;
		int row[2][100], col[2][100];	// Lưu thông tin con hậu, con mã
		int num[3];						// Số lượng con hậu, con mã, con tốt

		// Tiếp tục nhập đầu vào
		for(int i = 0; i < 3; i++)
		{
			cin >> num[i];
			for(int j = 0; j < num[i]; j++)
			{
				cin >> r >> c;
				Board[r-1][c-1] = i;
				if(i != 2)
				{
					row[i][j] = r - 1;
					col[i][j] = c - 1;
				}
			}
		}

		// Tính tổng các ô rảnh mà chưa có con nào đang đứng
		Sum -= num[Q] + num[K] + num[P];

		// Duyệt các con mã
		for(int j = 0; j < num[K]; j++)
			Sum -= checkK(row[K][j],col[K][j]);

		// Duyệt các con hậu
		for(int j = 0; j < num[Q]; j++)
			for(int i = 0; i < 8; i++)
				checkQ(row[Q][j], col[Q][j], i);

		cout <<"Board "<< tc <<" has " << Sum << " safe squares."<< endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài QUADAREA - Maximal Quadrilateral Area

admin@phamvanlam.com — Sat, 05 Nov 2016 14:52:00 GMT

Đề bài:

Bạn đang cố gắng để xây dựng một ngôi nhà. Nhưng không may, hiện tại bạn chỉ có sẵn 4 tường với chiều dài lần lượt là a, b, c, d. Bạn muốn ngôi nhà của bạn là lớn nhất có thể. Vì vậy, bạn muốn biết diện tích lớn nhất có thể của những hình tứ giác mà bạn có thể xây từ 4 bức tường với chiều dài đó.

Đầu vào

Dòng đầu tiên chứa số nguyên T, 1 ≤ T ≤ 2,000, là số lượng test case. Mỗi test case chứa một dòng gồm 4 số thực: a, b, c, d, với 0 < a, b, c, d < 1,000. Chú ý rằng luôn luôn có thể tồn tại hình tứ giác với những độ dài trên, tức là tổng của 3 cạnh luôn lớn hơn cạnh còn lại.

Đầu ra

Mỗi test case, in ra một dòng là một số biểu diễn diện tích lớn nhất có thể. Kết quả được làm tròn 2 chữ số thập phân.

Ví dụ

Đầu vào:

2
1 2 1 2
0.5 0.5 0.5 0.5

Đầu ra:

2.00
0.25

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/QUADAREA/

Phân tích

Theo như quan điểm của mình thì đây thực chất là một bài toán mẹo. Do đó mình sẽ xếp nó vào loạt bài sử dụng thuật toán tham lam Greedy.
Thực tế, với một hình tứ giác có 4 cạnh xác định trước. Thì dù bạn có xoay nó như thế nào đi chăng nữa thì diện tích của nó cũng sẽ không thay đổi - là một giá trị duy nhất. Do đó, bạn chỉ cần tính diện tích bình thường. Mình áp dụng công thức Heron để tính diện tích tứ giác lồi.

Lời giải

Code C/C++

#include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt", "r", stdin);

	int T;
	cin >> T;
	for(int tc = 0; tc < T; tc++)
	{
		double a,b,c,d;
		cin >> a >> b >> c >> d;

		double p = (a + b + c + d) / 2;
		double S = sqrt((p-a)*(p-b)*(p-c)*(p-d));

		printf("%.2lf\n", S);
	}
	return 0;
}

SPOJ.COM - Thuật toán bài QUE1 - Queue (Rookie)

admin@phamvanlam.com — Sat, 05 Nov 2016 14:19:00 GMT

Đề bài:

Có N ngưới đang đứng ở một hàng đợi. Bạn được đưa cho chiều cao của mỗi người và số những người cao hơn và đứng trước anh ta. Bạn hãy tìm ra vị trí của mỗi người.

Đầu vào

Bắt đầu bằng số nguyên T - là số lượng test case. Sau đó là T test case. Mỗi test case bao gồm 3 dòng. Dòng đầu tiên là số nguyên N. Dòng thứ hai là N số nguyên biểu diễn chiều cao của N người. Dòng thứ ba là N số nguyên biểu diễn số người cao hơn đứng trước anh ta.

Đầu ra

In ra một dòng cho mỗi test case, bao gồm chiều cao của N người theo đúng thứ tự của vị trí đứng.

Ràng buộc:

0 < T <= 100 
0 < N <= 1000

Ví dụ

Đầu vào:

1
5
33 11 22 44 55
0 2 1 1 0

Đầu ra:

33 22 11 55 44

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/QUE1/

Phân tích

Ở đây mình sử dụng thuật toán tham lam Greedy để giải quyết bài toán.

Trước tiên, mình sẽ sắp xếp dãy theo thứ tự tăng dần của độ cao. Sau khi có có dãy theo đúng thứ tự rồi, việc còn lại là tìm vị trí đúng cho từng người là vô cùng đơn giản.

Mình sử dụng một mảng để lưu kết quả. Với mỗi người mình sẽ duyệt từ trái sang phải và để lại số ô '-1' (tức là chưa được xếp) bằng với số người cao hơn phía trước người đang xét.

Ví dụ với bài toán trên:

Đầu tiên sắp xếp dãy tăng dần theo chiều cao mình được 2 dãy như sau:

11 22 33 44 55
2  1  0  1  0

Một mảng kết quả, khởi tạo các giá trị là -1:

-1 -1 -1 -1 -1

Đầu tiên, xét chiều cao 11: do có 2 người cao hơn nên mảng kết quả trở thành:

-1 -1 11 -1 -1 (2 số -1 phía trước là 2 người có chiều cao lớn hơn và đứng trước)

Tiếp theo, xét chiều cao 22: có 1 người cao hơn nên mảng kết quả trở thành:

-1 22 11 -1 -1

Tương tự như vậy ta có kết quả là:

33 22 11 -1 -1
33 22 11 -1 44
33 22 11 55 44

Lời giải

Code C/C++

#include <iostream>
using namespace std;

/*
* Hoán vị 2 số a và b
*/
void swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}

/*
* Sắp xếp dãy theo chiều tăng dần của dãy a
* Dãy b được đi kèm theo dãy a
* left, right: chỉ số trái, phải của dãy
*/
void QuickSort_Ascending(int *a, int *b, int left, int right)
{
	int i = left, j = right;
	int pivot = a[(i+j)/2];
	while(i <= j)
	{
		while(a[i] < pivot) i++;
		while(a[j] > pivot) j--;
		if(i <= j)
		{
			swap(a[i],a[j]);
			swap(b[i],b[j]);
			i++;
			j--;
		}
	}
	if(left < j) QuickSort_Ascending(a,b,left,j);
	if(i < right) QuickSort_Ascending(a,b,i,right);
}

int main()
{
	ios::sync_with_stdio(false);
	freopen("input.txt","r",stdin);

	int T, N;
	int height[1000];		// Lưu chiều cao của N người
	int numTallerBef[1000]; // Lưu số người cao hơn đứng trước
	int result[1000];		// Lưu dãy kết quả

	cin >> T;
	for(int i = 0; i < T; i++)
	{
		// Nhập đầu vào
		cin >> N;
		for(int i = 0; i <  N; i++)
			cin >> height[i];
		for(int i = 0; i < N; i++)
		{
			cin >> numTallerBef[i];
			result[i] = -1;
		}

		// Sắp xếp lại dãy theo chiều tăng dần của chiều cao
		QuickSort_Ascending(height, numTallerBef, 0, N-1);

		// Duyệt dãy sau khi sắp xếp để tìm vị trí đúng
		int count, j, temp;
		for(int i = 0; i < N; i++)
		{
			temp = numTallerBef[i];
			j = count = 0;

			if(temp == 0)
			{
				for(j = 0; j < N; j++)
					if(result[j] == -1) break;
				result[j] = height[i];
			}
			else
			{
				for(j = 0; j < N; j++)
				{
					if(result[j] == -1) count++;
					if(count == temp && result[j+1] == -1) break;
				}
				result[j+1] = height[i];
			}
		}
		for(int i = 0; i< N; i++)
			cout << result[i] << " ";
		cout << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài SAMER08F - Feynman

admin@phamvanlam.com — Sat, 05 Nov 2016 11:38:00 GMT

Đề bài:

Richard Phillips Feynman được biết đến như là một nhà vật lý và một người được nhận giải Nobel về vật lý. Ông làm việc trong ngành lý thuyết vật lý và tiên phong trong việc tính toán trường của lượng tử. Ông đã đến thăm Nam Mĩ được khoảng 10 tháng, giảng dạy và tận hưởng cuộc sống ở vùng chí tuyến này. Ông cũng được biết đến cho cuốn sách của mình "Surely You're Joking, Mr. Feynman!" và "What Do You Care What Other People Think?", bao gồm những cuộc phiêu lưu của ông ở vùng dưới xích đạo này.

Đam mê trong cuộc sống của ông là giải quyết và tạo ra những câu đố. Gần đây, một nông dân ở vùng Nam Mĩ, người là một ông chủ cho đến một nhà Vật lý năm 1949, đã tìm thấy một vài tờ giấy và những cuốn sổ ghi chú, cái được tin rằng là thuộc về Feynman. Ở giữa cuốn sổ, phần về vật lý Mezon và điện tử học, có một tờ giấy, ở đó Feynman đã ghi ra một câu đố đơn giản. Đó là: có bao nhiêu hình vuông khác nhau ở một cái lưới kích thước NxN.

Ở tờ giấy đó, có một hình vẽ, được chép lại như dưới đây, cho thấy với N = 2 thì đáp án là 5 hình vuông khác nhau.

Đầu vào

Bao gồm nhiều test case. Mỗi test case là 1 dòng, chứa số N, biểu diễn số hình vuông ở mỗi cạnh, (1 ≤ N ≤ 100). Kết thúc của đầu vào là số 0.

Đầu ra

Với mỗi test case, in ra một dòng chứa số lượng hình vuông khác nhau tương ứng với mỗi test case.

Ví dụ

Đầu vào:

Đầu ra:

5
1
204

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/SAMER08F/

Phân tích

Có thể sẽ có nhiều cách giải bài toán này. Ở đây mình đơn giản sử dụng thuật toán tham lam Greedy để giải quyết bài toán.
Yêu cầu của bài toán là tìm ra số hình vuông khác nhau ở trên lưới NxN. Dễ thấy rằng, kết quả sẽ là tổng số hình vuông có kích thước cạnh 1, cạnh 2, cạnh 3,... cạnh N.
Để đếm được hết tất cả các hình vuông mà không bị lặp, mình sẽ duyệt tất cả các ô trong lưới theo chiều từ trái sang phải, từ trên xuống dưới. Tại mỗi ô mình sẽ đếm số hình vuông có điểm bắt đầu là tại ô đó.
Trong ví dụ trên với N = 2:
- Trước tiên mình xét điểm (0,0): khi đó mình có 2 hình vuông bắt đầu tại điểm này là: hình 1 và hình 5
- Tiếp theo là điểm (0, 1): chỉ có 1 hình là hình 2
- Xét điểm (1, 0): có 1 hình là hình 3
- Xét điểm (0, 1): có 1 hình là hình 4.
Như vậy, tổng là 5 hình.
Qua phân tích, mình suy ra một công thức đó là: tại điểm (row, col), số hình vuông có điểm bắt đầu tại đó là: N - Max(row, col). Bạn có thể thử lại nếu như còn thấy nghi ngờ về công thức này.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int main()
{
	ios::sync_with_stdio(false);
	freopen("input.txt","r",stdin);

	// Kích thước lưới
	int N = 0;
	while(true)
	{
		cin >> N;
		if(N == 0) break;

		// Đếm số lượng hình vuông khác nhau.
		int num = 0;

		// Duyệt các điểm và đếm số hình vuông
		// có chứa ô đầu tiên nằm tại vị trí (row, col)
		for(int row = 0; row < N; row++ )
		{
			for(int col = 0; col < N; col++)
			{
				int max = (row > col) ? row : col;
				num += N - max;
			}
		}
		cout << num << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài SERGRID - Grid

admin@phamvanlam.com — Thu, 03 Nov 2016 21:16:00 GMT

Đề bài:

Bạn đang ở trên một cái lưới nxm nơi mà mỗi ô vuông trên lưới đó có một số trên đó. Từ một ô cho trước trên lưới có một số có giá trị k. Một lần di chuyển bao gồm chính xác k ô vuông theo 4 hướng chính. Biết bạn không thể nhảy ra khỏi lưới. Hỏi số bước nhỏ nhất để di chuyển từ ô vuông trên cùng bên trái đến ô vuông dưới cùng bên phải là bao nhiêu.

Đầu vào

Mỗi đầu vào sẽ bao gồm một test case duy nhất. Chú ý rằng chương trình của bạn có thể được chạy nhiều lần trên những đầu vào khác nhau. Dòng đầu tiên của đầu vào bao gồm 2 số nguyên n và m được ngăn cách bởi dấu cách (1 <= n, m <= 500), biểu thị kích thước của lưới. Đảm bảo rằng ít nhất một cạnh của lưới (tức n hoặc m) sẽ lớn hơn 1. n dòng tiếp theo, mỗi dòng chứa m chữ số và không có dấu cách, biểu thị ma trận nxm. Mỗi chữ số có giá trị từ 0 đến 9 (bao gồm cả 2 chữ số đó). Ô vuông trên cùng bên trái của lưới tương ứng với kí tự đầu tiên, của dòng đầu tiên, của mỗi test case. Ô vuông dưới cùng bên phải tương ứng với kí tự cuối cùng, của dòng cuối cùng, của mỗi test case.

Đầu ra

In ra duy nhất trên 1 dòng một số - biểu diễn giá trị là số bước nhỏ nhất để di chuyển từ góc trên cùng bên trái xuống góc dưới cùng bên phải. Nếu không thì in ra -1.

Ví dụ

Đầu vào:

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/SERGRID/

Phân tích

Đây là bài toán cơ bản áp dụng thuật toán tìm kiếm theo chiều rộng BFS. Mình sẽ bắt đầu từ điểm đầu tiên là điểm trên cùng bên trái. Rồi đi tới các điểm kề với nó theo 4 hướng với quy tắc là số bước nhảy đúng bằng giá trị của ô đang xét hiện tại.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 505;
const int MAX_QUEUE = MAX*MAX;

int n, m;               // Kích thước ma trận
int Matrix[MAX][MAX];   // Ma trận ban đầu
int Mark[MAX][MAX];     // Ma trận đánh dấu

typedef struct
{
	int row;
	int col;
}Point;

// Hàng đợi vòng
Point queue[MAX_QUEUE];
int fr, re, leng;

void Enqueue(int row, int col)
{
	Point p;
	p.row = row;
	p.col = col;

	queue[re] = p;
	re = (re + 1) % MAX_QUEUE;
	leng++;
}

Point Dequeue()
{
	Point p = queue[fr];
	fr =  (fr + 1) % MAX_QUEUE;
	leng--;
	return p;
}

int drow[] = {-1,0,1, 0};
int dcol[] = { 0,1,0,-1};

/*
* Thuật toán BFS từ điểm đầu tiên (sr, sc)
*/
void BFS(int sr, int sc)
{
	fr = re = leng = 0;
	Mark[sr][sc] = 1;
	Enqueue(sr,sc);

	while(leng > 0)
	{
		Point p = Dequeue();
		for(int i = 0; i < 4; i++)
		{
			int r = p.row + (drow[i]) * Matrix[p.row][p.col];
			int c = p.col + (dcol[i]) * Matrix[p.row][p.col];
			if( r >= 0 && r < n && c >= 0 && c < m &&
			    (Mark[r][c] == 0 || Mark[r][c] > Mark[p.row][p.col] + 1)
			    )
			{
				Mark[r][c] = Mark[p.row][p.col] + 1;
				Enqueue(r,c);
			}
		}
	}
}

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);

	cin >> n >> m;
	for(int i = 0; i < n; i++)
	{
		char tmp[MAX];
		cin >> tmp;
		for(int j = 0; j < m; j++)
		{
			Matrix[i][j] = tmp[j] - '0';
			Mark[i][j]   = 0;
		}
	}

	BFS(0,0);

	// Nếu giá trị ô cuối cùng vẫn bằng 0, nghĩa là nó được thăm
	if(Mark[n-1][m-1] == 0) cout << -1 << endl;
	else cout << Mark[n-1][m-1] - 1 << endl;
	return 0;
}

SPOJ.COM - Thuật toán bài SHOP - Shopping

admin@phamvanlam.com — Thu, 03 Nov 2016 20:50:00 GMT

Đề bài:

Màn hình ống cũ máy tính của bạn hóa ra là nguyên nhân gây ra đau đầu mãn tính của bạn. Do đó bạn quyết định mua một trong những màn hình TFT phẳng mới. Tại lối vào của cửa hàng máy tính, bạn thấy rằng có khá đông đủ khách hàng.

(Câu tiếp theo mình không hiểu lắm. Tuy nhiên nó không quan trọng, nên mình sẽ bỏ qua. Nếu bạn hiểu câu này nói gì, vui lòng viết dưới phần bình luận để mọi người cùng hiểu nhé.) Bởi vì, bạn muốn về nhà sớm để hoàn thành công việc còn dang dở ở trên SPOJ; nên bạn muốn lé tránh đám đông được nhiều nhất có thể. Bạn xem xét tình hình ở một vài nơi và nhận ra rằng đám đông là ít hơn ở một vài chỗ ở cửa hàng. Đó là lí do cho bạn để hy vọng rằng bạn sẽ đến đích đúng giờ, với quãng đường đi ngắn nhất. Nhưng đường đi ngắn nhất là đường nào?

Bạn phác họa tình hình trên một miếng giấy. Tuy nhiên nó vẫn là một vấn đề khó. Bạn lấy ra một cuốn sổ trong túi và viết một chương trình để tìm đường đi ngắn nhất cho bạn.

Đầu vào

Dòng đầu tiên của đầu vào miêu tả chiều rộng w và chiều dài h của cửa hàng. Cả hai chiều đều không vượt quá 25. h dòng tiếp theo, mỗi dòng chứa w kí tự. Trong đó, kí tự 'S' miêu tả cái giá, kí tự 'S' là vị trí bắt đầu và kí tự 'D' là đích đến (ví dụ là một hình vuông phía trước những màn hình). Tất cả những khối hình vuông trống được đánh số từ 1 đến 9 - là số giây cần để vượt qua khu vực hình vuông đó.

Có rất nhiều test case và được ngăn cách nhau bởi dòng trống. Đầu vào kết thúc bởi giá trị độ rộng và chiều dài là 0 0.

Đầu ra

Với mỗi test case, in ra giá trị số giây nhỏ nhất để đi được tới đích. Mỗi test case in ra trên một dòng riêng biệt. Bạn có thể di chuyển theo chiều ngang hay chiều dọc. Dĩ nhiên, bạn phải di chuyển bên trong của ma trận. Và luôn có đường để tới đích.

Ví dụ

Đầu vào:

Đầu ra:

4
23

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/SHOP/

Phân tích

Đây là bài toán tìm đường đi ngắn nhất cơ bản trên ma trận. Nó tương đương với bài toán tìm đường đi ngắn nhất của đồ thị có trọng số (vì các đường đi có giá khác nhau). Vì vậy, mình sử dụng thuật toán Dijkstra để giải quyết bài toán.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX_INT = 1<<20;
const int MAX = 30;

int w, h;               // Kích thước ma trận
int SR, SC, DR, DC;     // Lần lượt là hàng, cột của điểm bắt đầu, kết thúc
int number;             // Số lượng điểm mà bạn có thể đi vào
int Matrix[MAX][MAX];   // Ma trận đầu vào
int Distance[MAX][MAX]; // Ma trận khoảng cách sau khi áp dụng Dijkstra
bool Mark[MAX][MAX];    // Ma trận đánh dấu

/*
* Tìm điểm chưa thăm, có thể đi và giá trị ma trận khoảng cách là nhỏ nhất
* Tham số dạng tham chiếu để lưu tọa độ hàng, cột tìm được
*/
void FindMin(int &rmin, int &cmin)
{
	int _min = MAX_INT;
	for(int i = 0; i < h; i++)
		for(int j = 0; j < w; j++)
			if(Mark[i][j] == false && Matrix[i][j] != -1 && Distance[i][j] < _min)
			{
				_min = Distance[i][j];
				rmin = i;
				cmin = j;
			}
}

int drow[] = {-1,0,1, 0};
int dcol[] = { 0,1,0,-1};

/*
* Thuật toán Dijkstra tại điểm bắt đầu là (sr, sc)
*/
void Dijkstra(int sr, int sc)
{
    // Đếm số điểm đã xét, khi duyệt hết các điểm có thể thì dừng
	int cnt = 0;
	Distance[sr][sc] = 0;
	while (cnt < number)
	{
		int rmin = 0, cmin = 0;
		FindMin(rmin,cmin);

		Mark[rmin][cmin] = true;
		cnt++;
		for(int i = 0; i < 4; i++)
		{
			int r = rmin + drow[i];
			int c = cmin + dcol[i];
			if( r >= 0 && r < h && c >= 0 && c < w &&
			    Mark[r][c] == false && Matrix[r][c] != -1 &&
			    Distance[rmin][cmin] + Matrix[r][c] < Distance[r][c]
			    )
				Distance[r][c] = Distance[rmin][cmin] + Matrix[r][c];
		}
	}
}

int main()
{
	ios::sync_with_stdio(false);
//	freopen("input.txt","r",stdin);

	while(true)
	{
		cin >> w >> h;
		if(w==0 && h==0) break;

		SR = SC = DR = DC = number = 0;
		for(int i = 0; i < h; i++)
		{
			char temp[MAX];
			cin >> temp;
			for(int j = 0; j < w; j++)
			{
				if(temp[j]=='X')
				{
					Matrix[i][j] = -1;
					number++;
				}
				else if(temp[j]=='S')
				{
					Matrix[i][j] = 0;
					SR = i;
					SC = j;
				}
				else if(temp[j]=='D')
				{
					Matrix[i][j] = 0;
					DR = i;
					DC = j;
				}
				else Matrix[i][j] = temp[j] - '0';
				Distance[i][j] = MAX_INT;
				Mark[i][j] = false;
			}
		}
		number = w*h - number;
		Dijkstra(SR,SC);
		cout << Distance[DR][DC] << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài ANARC05B - The Double HeLiX

admin@phamvanlam.com — Mon, 31 Oct 2016 20:06:00 GMT

Đề bài:

Cho 2 dãy số nguyên hữu hạn, tăng nghiêm ngặt. Bất kì những số nguyên nào giữa 2 dãy thì đều tạo nên điểm giao nhau giữa hai dãy. Ví dụ với 2 dãy sau, những điểm giao nhau là những điểm được in đậm:

Dãy 1: 3 5 7 9 20 25 30 40 55 56 57 60 62
Dãy 2: 1 4 7 11 14 25 44 47 55 57 100

Bạn có thể di chuyển giữa hai dãy bằng cách sau:

Cách 1. Bạn bắt đầu từ điểm đầu của 1 trong 2 dãy. Rồi di chuyển về phía trước.
Cách 2. Tại điểm nối, bạn có 2 sự lựa chọn là tiếp tục di chuyển trên dãy đó, hoặc là chuyển sang dãy mới.

Mục đích là tìm ra đường đi cho ra tổng các ô bạn đi là lớn nhất. Trong ví dụ trên tổng lớn nhất là 450, nó là kết quả của việc đi theo đường:

3, 5, 7, 9, 20, 25, 44, 47, 55, 56, 57, 60, và 62

Đầu vào

Có nhiều testcase, mỗi cái được xác định trên 2 dòng. Mỗi dòng biểu diễn một dãy và có định dạng:

n v1 v2 ... vn

Trong đó, n là độ dài của dãy, vi là phần tử thứ i của dãy. Mỗi dãy sẽ có ít nhất 1 phần tử nhưng không lớn hơn 10000. Tất cả phần tử đều thuộc từ -10000 đến 10000 (bao gồm 2 giá trị biên). Dòng cuối cùng của đầu vào sẽ là số 0, và nó không thuộc vào các test case.

Đầu ra

Mỗi một test case, in ra trên một dòng giá trị lớn nhất có thể.

Ví dụ

Đầu vào:

13 3 5 7 9 20 25 30 40 55 56 57 60 62
11 1 4 7 11 14 25 44 47 55 57 100
4 -5 100 1000 1005
3 -12 1000 1001
0

Đầu ra:

450
2100

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/ANARC05B/

Phân tích

Ở đây, mình kết hợp 2 thuật toán là: thuật toán chia để trị Divide and conquer và thuật toán quy hoạch động Dynamic programming để giải quyết bài toán.
Thuật toán chia để trị nhằm mục đích tìm ra thành phần chung nhau của 2 dãy. Ý tưởng ở đây là với mỗi số thuộc dãy 1. Mình sẽ sử dụng tìm kiếm nhị phân để tìm ra vị trí của nó trong dãy số 2. Kết quả là mình xác định được vị trí trùng nhau của các phần tử trên 2 dãy.
Thuật toán quy hoạch động là để tìm ra giá trị lớn nhất tại mỗi điểm khi đi từ đầu đến cuối dãy. Một điều chú ý ở đây là tại mỗi dãy, ở các điểm trùng nhau ta có thể đi sang nhau. Do đó, giá trị lớn nhất tại 2 điểm trùng nhau khi ta đi từ đầu dãy đến đó là bằng nhau và bằng giá trị lớn nhất của 2 phần tử ở hai dãy.

Lời giải

Code C/ C++

#include <iostream>
using namespace std;

const int MAX = 10005;

int N[2];           // Lưu số chiều dài của 2 dãy
int Seq[2][MAX];    // Lưu thông tin 2 dãy
int Common[2][MAX]; // Lưu id thành phần chung của 2 dãy
int NumCmn;         // Độ dài thành phần chung 2 dãy
int First, Second;  // Dãy ngắn hơn gọi là First, dãy còn lại là Second
int MaxSum[2][MAX]; // Tính giá trị lớn nhất tại mỗi điểm khi đi từ đầu

/*
* Tìm trong mảng a, độ dài leng, phần tử có giá trị k
* RETURN: chỉ số của phần tử k trong mảng nếu tìm thấy, ngược lại là -1
*/
int BinarySearch(int *a, int leng, int k)
{
	int left = 1, right = leng, mid = 0;
	while(left < right)
	{
		mid = (left + right) / 2;
		if(a[mid] == k) return mid;

		if(a[mid] > k) right = mid - 1;
		else left = mid + 1;
	}
	if(a[left] == k) return left;
	return -1;
}

int main(int argc, char** argv)
{
	//freopen("input.txt", "r", stdin);
	ios::sync_with_stdio(false);

	cin >> N[0];

	while(N[0] != 0)
	{
		// Nhập đầu vào
		for(int i = 1; i <= N[0]; i++)
			cin >> Seq[0][i];
		cin >> N[1];
		for(int i = 1; i <= N[1]; i++)
			cin >> Seq[1][i];

		// Tìm dãy ngắn hơn
		if(N[0] < N[1]) First = 0;
		else First = 1;
		Second = 1 - First;

		// Duyệt dãy ngắn hơn để tìm ra thành phần chung
		NumCmn = 0;
		for(int i = 1; i <= N[First]; i++)
		{
			// Tìm trong dãy hai, vị trí của 1 số có giá trị ở dãy 1 đang xét
			int t = BinarySearch(Seq[Second], N[Second], Seq[First][i]);

			// Nếu tìm thấy
			if(t != -1)
			{
				NumCmn += 1;
				Common[First][NumCmn] = i;
				Common[Second][NumCmn] = t;
			}
		}

		// Tìm giá trị lớn nhất tại mỗi điểm bằng cách đi từ đầu
		MaxSum[First][0] = 0;
		MaxSum[Second][0]= 0;
		for(int c = 1; c <= NumCmn; c++)
		{
			for(int i = Common[First][c-1]; i < Common[First][c]; i++)
				MaxSum[First][i + 1] = MaxSum[First][i] + Seq[First][i + 1];

			for(int i = Common[Second][c-1]; i < Common[Second][c]; i++)
				MaxSum[Second][i + 1] = MaxSum[Second][i] + Seq[Second][i + 1];

			int t = max(MaxSum[First][Common[First][c]], MaxSum[Second][Common[Second][c]]);
			MaxSum[First][Common[First][c]] = MaxSum[Second][Common[Second][c]] = t;
		}

		for(int i = Common[First][NumCmn]; i < N[First]; i++)
			MaxSum[First][i + 1] = MaxSum[First][i] + Seq[First][i + 1];
		for(int i = Common[Second][NumCmn]; i < N[Second]; i++)
			MaxSum[Second][i + 1] = MaxSum[Second][i] + Seq[Second][i + 1];

		// In kết quả
		cout << max(MaxSum[First][N[First]], MaxSum[Second][N[Second]]) << endl;
		cin >> N[0];
	}
	return 0;//Your program should return 0 on normal termination.
}

SPOJ.COM - Thuật toán bài DCEPC501 - Save Thy Toys

admin@phamvanlam.com — Mon, 31 Oct 2016 19:48:00 GMT

Đầu bài:

Leonard rất yêu thích việc mua sắm những đồ chơi khoa học viễn tưởng hiếm và đắt. Anh ta giữ chúng theo một dãy theo thứ tự ngày mua và để trong một cái tủ. Vì vậy, Sheldon sẽ không bao giờ lấy được đồ chơi của anh ta. Nhưng vì một lần không may mắn, Leonard đã thu Sheldon trong một vụ cá cược. Và Sheldon đã yêu cầu Leonard chia sẻ đồ chơi. Bởi vì, Leonard không muốn mất nhiều tiền nên anh ta đã quyết định dựa trên một chiến lược để giảm thiểu sự mất mát xuống thấp nhất.

Leonard bắt đầu chọn từ đồ chơi đầu tiên ở trong tủ, sẽ lấy một số đồ chơi, gọi là 'x' đồ chơi. Sheldon sau đó sẽ chọn 'x' đồ chơi (chú ý là Sheldon sẽ chọn số đồ chơi bằng với Leonard, trừ khi số đồ chơi còn lại nhỏ hơn 'x'). Việc này sẽ tiếp tục cho đến khi không còn lại đồ chơi nào nữa.

Bạn được đưa cho một dãy của đồ chơi với giá của chúng. Hãy giúp Leonard lấy được đồ chơi với số tiền lớn nhất có thể. Leonard chỉ có thể chọn 1, 2 hay 3 đồ chơi ('x' có giá trị 1, 2 hay 3)

Đầu vào:

Dòng đầu tiên là T, số lượng testcase. Mỗi testcase chứa N ở dòng đầu tiên. Dòng thứ 2 là N số nguyên là giá tiền của các đồ chơi.

Đầu ra:

In ra 1 số nguyên trên một dòng cho mỗi test case là tổng số tiền lớn nhất của các đồ chơi mà Leonard chọn.

Ràng buộc:

1 <= T <= 10 
1 <= N <= 100000 
1 <= Giá của đồ chơi <= 1000000

Ví dụ:

Đầu vào:

2
4
5 4 3 2
6
10 8 7 11 15 20

Đầu ra:

12
53

Giải thích:

Ở test case 1: Leonard chọn 3 đồ chơi trong lần đầu tiên của anh ta là: 5, 4, 3. Do đó, Sheldon không còn lựa chọn nào khác nên phải chọn 2. Khi đó, Leonard thu được tổng số tiền lớn nhất là 5 + 4 + 3 = 12
Ở test case 2: Leonard chọn 10 và 8. Sau đó, Sheldon chọn 7 và 11. Cuối cùng Leonard chọn 15 và 20. Do đó, số tiền lớn nhất mà Leonard thu được là: 10 + 8 + 15 + 20 = 53

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/DCEPC501/

Phân tích:

Ở đây, mình sử dụng thuật toán quy hoạch động Dynamic programming để giải quyết bài toán. Và cách triển khai là kiểu bottom-up (tức là sử dụng vòng lặp). Có một vài điều cần chú ý ở đây là:

Leonard sẽ có 3 cách lựa chọn là: chọn 1, 2 hoặc 3 vật.
Kết quả có thể rất lớn nên phải sử dụng kiểu long long (64 bit) để lưu kết quả

Lời giải

Code C/ C++

#include <iostream>
using namespace std;

const int MAX = 1000010;

int N;                      // Số đồ chơi
int Price[MAX];             // Giá của các đồ chơi
long long MaxMoney[MAX];    // MaxMoney[i] là số tiền lớn nhất
                            // khi Leonard chọn từ đồ chơi thứ i.
int main(int argc, char** argv)
{
	int T, test_case;
	ios::sync_with_stdio(false);
	//freopen("input.txt", "r", stdin);

	cin >> T;
	for(test_case = 0; test_case  < T; test_case++)
	{
		// Nhập đầu vào
		cin >> N;
		for(int i = 1; i <= N; i++)
		{
			cin >> Price[i];
			MaxMoney[i] = 0;
		}

		// Trường hợp cơ sở
		MaxMoney[N] = Price[N];
		for(int i = N + 1; i <= N + 5; i++)
			Price[i] = MaxMoney[i] = 0;

		for(int i = N-1; i >= 1; i--)
		{
			// Nếu chọn 1 đồ chơi
			MaxMoney[i] = (long long)Price[i] + MaxMoney[i + 2];

			// Nếu chọn 2 đồ chơi
			long long t = (long long)(Price[i] + Price[i + 1]) + MaxMoney[i + 4];
			if(t > MaxMoney[i]) MaxMoney[i] = t;

			// Nếu chọn 3 đồ chơi
			t = (long long)(Price[i] + Price[i + 1] + Price[i + 2]) + MaxMoney[i + 6];
			if(t > MaxMoney[i]) MaxMoney[i] = t;
		}
		cout << MaxMoney[1] << endl;
	}
	return 0;//Your program should return 0 on normal termination.
}

SPOJ.COM - Thuật toán bài ADFRUITS - Advanced Fruits

admin@phamvanlam.com — Sat, 29 Oct 2016 21:43:00 GMT

Đề bài:

Công ty "21st Century Fruits" đã sáng tạo ra những loại nước hoa quả mới bằng cách chuyển gen từ một loại sang một loại khác. Hầu hết các lần là thất bại Nhưng đôi khi một loại nước hoa quả mới sẽ được tạo ra bằng cách trộn chúng lại với nhau.

Một chủ đề lớn được đưa ra thảo luận đó là "Phát minh mới này sẽ được gọi là gì?" Kết hợp giữa apple và pear sẽ được gọi là apple-pear. Dĩ nhiên, gọi như vậy nghe không hay ho lắm. Ông chủ công ty mới ra quyết định đó là sử dụng một chuỗi ngắn nhất chứa cả tên của cả hai loại. Ví dụ: "applear" bao gồm "apple" và "pear" (APPLEar và apPlEAR), và không có một xâu nào ngắn hơn thoả mãn tính chất trên.

Tổ hợp của "cranberry" và "boysenberry" là "boysecranberry" hay "craboysenberry" Nhiệm vụ của bạn là viết ra một chương trình để tính ra tên có độ dài nhỏ nhất là tổ hợp của 2 loại quả ban đầu.

Đầu vào

Mỗi dòng bao gồm 2 xâu là tên của 2 loại quả ban đầu. Tất cả tên có độ dài tối đa là 100 và chỉ chứa kí tự là chữ cái. Kết thúc đầu vào là kí hiệu kết thúc file.

Đầu ra

Mỗi test case, in ra tên nhỏ nhất của kết quả trên một dòng. Nếu có nhiều kết quả thì chỉ cần in ra một cái bất kỳ.

Ví dụ

Đầu vào:

apple peach
ananas banana
pear peach

Đầu ra:

appleach
bananas
pearch

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/ADFRUITS/

Phân tích

Ở đây mình sử dụng thuật toán quy hoạch động Dynamic programming để tìm ra dãy con chung dài nhất của hai cái tên.
Sau khi đã có dãy con chung dài nhất của của hai dãy rồi thì mình chỉ việc in ra kết quả theo thứ tự thỏa mãn bài toán.

Lời giải

Code C/ C++

#include <iostream>
using namespace std;
const int MAX = 105;

char S1[MAX], S2[MAX];
int Leng1, Leng2;
int L[MAX][MAX];            // L[i][j] là độ dài LCS của S1[1..i] và S2[1...j]
char Common[MAX][MAX][MAX]; // Lưu thành phần chung dài nhất với L[i][j] trên.
char Result[2*MAX];         // Lưu kết quả
int Leng;                   // Độ dài mảng kết quả

/*
* Trả về độ dài xâu s
*/
int GetLeng(char *s)
{
	int leng = 0;
	while(s[leng] != '\0') leng++;
	return leng;
}

/*
* Sao chép xâu src với độ dài leng vào xâu dst
*/
void CpyStr(char *dst, char *src, int leng)
{
	for(int i = 0; i < leng; i++)
		dst[i] = src[i];
	dst[leng] = '\0';
}

int main(int argc, char** argv)
{
	ios::sync_with_stdio(false);
	//freopen("input.txt", "r", stdin);

	cin >> S1;
	while(true)
	{
		// Nhập xâu S1, S2 và tính độ dài của nó
		cin >> S2;
		Leng1 = GetLeng(S1);
		Leng2 = GetLeng(S2);

		// Trường hợp cơ sở
		for(int i = 0; i <= Leng1; i++)
			L[i][0] = 0;
		for(int j = 0; j <= Leng2; j++)
			L[0][j] = 0;

		for(int i = 1; i <= Leng1; i++)
			for(int j = 1; j <= Leng2; j++)
			{
				// Chỉ số mảng char* tính từ 0
				// Nếu hai kí tự đang xét giống nhau
				// thì cho vào dãy chung tăng dài nhất
				if(S1[i-1] == S2[j-1])
				{
					L[i][j] = 1 + L[i-1][j-1];
					CpyStr(Common[i][j], Common[i-1][j-1], L[i-1][j-1]);

					Common[i][j][L[i][j] - 1] = S1[i - 1];
					Common[i][j][L[i][j]] = '\0';
				}
				else // S1[i-1] != S2[j-1] thì giữ lại dãy nào có độ dài lớn hơn
				{
					// Chọn thành phần lớn hơn
					if(L[i-1][j] > L[i][j-1])
					{
						L[i][j] = L[i-1][j];
						CpyStr(Common[i][j], Common[i-1][j], L[i-1][j]);
					}
					else
					{
						L[i][j] = L[i][j-1];
						CpyStr(Common[i][j], Common[i][j-1], L[i][j-1]);
					}
				}
			}

        // In kết quả
		int i1 = 0;	// Con trỏ vào đầu s1
		int i2 = 0; // Con trỏ vào đầu s2
		int c  = 0; // Con trỏ vào đầu xâu common[Leng1][Leng2]

		Leng = 0;
		while(Common[Leng1][Leng2][c] != '\0')
		{
		    // In ra thành phần ở S1 cho đến thành phần chung
			while(S1[i1] != Common[Leng1][Leng2][c])
				Result[Leng++] = S1[i1++];

            // In ra thành phần sở S2 cho đến thành phần chung
			while (S2[i2] != Common[Leng1][Leng2][c])
				Result[Leng++] = S2[i2++];

            // In ra thành phần chung, rồi tăng con trỏ lên và tiếp tục
			Result[Leng++] = Common[Leng1][Leng2][c];
			c  += 1;
			i1 += 1;
			i2 += 1;
		}

        // Sau khi in hết thành phần chung rồi, thì in nốt S1 rồi S2
		for(int i = i1; i < Leng1; i++)
			Result[Leng++] = S1[i];
		for(int i = i2; i < Leng2; i++)
			Result[Leng++] = S2[i];
		Result[Leng] = '\0';

		cout << Result << endl;
		if(!(cin >> S1)) break;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài LKS - Large Knapsack

admin@phamvanlam.com — Sat, 29 Oct 2016 21:25:00 GMT

Đề bài:

Bài toán knapsack hay rucksack là một bài toán trong combinatorial optimization: Cho một tập gồm những phần tử. mỗi phần tử bao gồm trọng lượng và giá trị. Xác định số lượng mỗi phần tử được chọn sao cho tổng trọng lượng nhỏ hơn hoặc bằng với giới hạn cho trước và tổng giá trị là lớn nhất có thể.

Đầu vào:

Dòng đầu tiên bao gồm 2 số nguyên K và N, trong đó K là kích thước giới hạn của cái túi (knapsack) và N là số lượng phần tử. N dòng tiếp theo trong đó dòng thứ i là phần tử thứ i với giá trị v_i và trọng lượng w_i.

Đầu ra

In ra số nguyên duy nhất, là giá trị lớn nhất có thể của chiếc túi. (Tất cả các phép toán đảm bảo trong phạm vi của số nguyên có dấu 32 bit)

Ví dụ

Đầu vào

Đầu ra

Giới hạn:

K <= 2000000 N <= 500 V_i <= 10^7 W_i <= 10^7

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/LKS/

Phân tích

Đây là bái toán Knapsack 0/1 cơ bản. Nghĩa là mỗi đồ vật sẽ có thể được chọn hay không được chọn. Và nếu được chọn thì không giới hạn số lần chọn. Thuật toán được sử dụng ở đây là thuật toán quy hoạch động Dynamic Programming

Bình thường thì mình sẽ sử dụng một mảng hai chiều kích thước NxK, là MaxCost[N][k]. Trong đó, MaxCost[i][j] là giá trị lớn nhất thu được với việc chọn đồ vật từ 1 đến i và trọng lượng không vượt quá j.

Nhưng do số lượng đầu vào khá lớn nên mình không thể sử dụng một mảng 2 chiều NxK được. Tuy nhiên, nếu bạn để ý rằng giá trị tại hàng thứ i chỉ phụ thuộc vào hàng trước đó i - 1 (thuật toán bạn sẽ thấy rõ hơn ở dưới). Nên mình chỉ cần một mảng 2 chiều 2xK, trong đó một hàng dùng để lưu giá trị hàng thứ i - 1 và một hàng lưu giá trị hàng i. Sau khi tính được hàng i, mình lại hoán đổi vai trò của hai hàng cho nhau. Cứ như vậy, mình sẽ tính được giá trị của hàng thứ N.

Lời giải

Code C/ C++

#include <iostream>
using namespace std;

const int MAX_N = 505;
const int MAX_K = 2000005;

int K, N;
int Value[MAX_N], Weight[MAX_N];
int MaxCost[2][MAX_K];
// MAX[1][j] là giá trị lớn nhất thu được
// với việc chọn từ đồ vật từ 1 đến i và
// khối lượng không vượt quá j

// MAX[0][j] là giá trị cũ trước đó.
// Và ngược lại

int Max(int a, int b)
{
	if(a > b) return a;
	return b;
}

int main()
{
	int T, test_case;
	ios::sync_with_stdio(false);
	//freopen("input.txt", "r", stdin);

	cin >> K >> N;
	for(int i = 1; i <= N; i++)
	    cin >> Value[i] >> Weight[i];

	// Trường hợp cơ sở
	for(int j = 0; j <= K; j++)
		MaxCost[0][j] = 0;

	for(int i = 0; i < 2; i++)
		MaxCost[i][0] = 0;

	int before = 0, current = 1;
	for(int i = 1; i <= N; i++)
	{
		for(int j = 1; j <= K; j++)
		{
			// Không chọn vật i
			MaxCost[current][j] = MaxCost[before][j];

			// Chọn vật i
			if(Weight[i] <= j) MaxCost[current][j] =
			Max(MaxCost[current][j], MaxCost[before][j - Weight[i]] + Value[i]);
		}

		// Đổi current và before cho nhau.
		current = 1 - current;
		before  = 1 - before;
	}
	// N chẵn thì kết quả là MaxCost[0][K]
	// N lẻ thì kết quả là MaxCost[1][K]
	cout << MaxCost[N % 2][K] << endl;

	return 0;//Your program should return 0 on normal termination.
}

SPOJ.COM - Thuật toán bài ACODE - Alphacode

admin@phamvanlam.com — Sat, 29 Oct 2016 21:02:00 GMT

Đề bài:

Alice và Bob cần gửi những tin nhắn bí mật cho nhau. Và họ đã thảo luận ra cách để mã hoá chúng:

Alice: "Chúng ta hãy sử dụng một cách đơn giản. Chúng ta sẽ cho 'A' ứng với 1, 'B' ứng với 2,..., cứ như vậy thì 'Z' sẽ ứng với 26"

Bob: "Đó là một cách mã hoá ngớ ngẩn, Alice. Giả sử tớ muốn gửi cho cậu từ 'BEAN' thì mã sẽ là 25114. Cậu có thể giải mã nó với nhiều cách khác nhau."

Alice: "Dĩ nhiên là cậu có thể. Tuy nhiên, cậu sẽ chọn từ nào? Ngoài 'BEAN' ra thì còn có 'BEAAD', 'YAAD', 'YAN', 'YKD' và 'BEKD'. Tớ nghĩ cậu sẽ tìm ra cách giải mã đúng nhất. Và tại sao cậu lại gửi cho tớ từ 'BEAN'"

Bob: "OK, có lẽ đây là một ví dụ không tốt. Nhưng tớ cá là nếu như độ dài xâu là 5000 thì sẽ có hàng tấn cách giải mã khác nhau. Và với rất nhiều những cách đó, chắc hẳn cậu sẽ tìm ra ít nhất 2 cái có nghĩa"

Alice: "Có bao nhiêu cách giải mã?"

Bob: "Hàng tỉ tỉ cách" Vì một số lí do, Alice vẫn không bị thuyết phục bởi Bob. Vì vậy, cô ấy yêu cầu Bob viết một chương trình để xác định xem có bao nhiêu cách giải mã đối với một xâu cho trước.

Đầu vào

Bao gồm nhiều test case, mỗi cái sẽ bao gồm 1 dòng chứa một xâu có tối đa 5000 chữ số, biểu diễn một cách mã hoá hợp lệ. Ví dụ: không có dòng nào bắt đầu bởi '0'. Và không có khoảng cách giữa các kí tự. Đầu vào kết thúc bởi '0'.

Đầu ra

In đáp án. tất cả đáp án sẽ trong phạm vi giới hạn của số nguyên có dấu 64 bit.

Ví dụ

Đầu vào:

Đầu ra:

6
89
1

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/ACODE/

Phân tích

Ở đây mình sử dụng thuật toán quy hoạch động Dynamic programming và triển khai theo kiểu top - down. Nghĩa là mình sẽ viết hàm đệ quy để giải quyết bài toán này.

Mình sẽ dùng một mảng một chiều là Memo[MAX]. Trong đó, Memo[i] là số cách giải mã được khi tính từ kí tự i đến cuối (i được tính từ 0). Và hàm đệ quy tương ứng là Solve(i)

Ở đây, vì các chữ cái từ 'A' đến 'Z' tương ứng với các số từ 1 đến 26. Do đó, khi duyệt mình cần chú ý đến hai trường hợp là chọn 1 chữ số hay 2 chữ số để giải mã.

Có một chú ý ở đây là chữ số '0' không thể đứng một mình và không thể đứng trước một chữ số khác. Tức là nếu mình có đầu vào là: 1026 thì ở đây, chữ cái đầu tiên chắc chắn là K, tương ứng với số 10. Do đó, kết quả có thể là KBF hoặc KZ. Không thể lấy số 1 ra để giải mã. Vì khi đó ta có A026. Mà số 0 hay 02 thì không hợp lệ.

Công thức đệ quy mình sẽ viết rõ ở trong code. Bạn có thể tham khảo ở dưới.

Lời giải

Code C/ C++

#include <iostream>
using namespace std;

const int MAX = 5005;

char Str[MAX];
int Leng;
long long Memo[MAX];// Memo[i] là số cách tính từ kí tự i đến cuối.

int GetLeng(char *s)
{
	int leng = 0;
	while(s[leng] != '\0') leng++;
	return leng;
}

/*
* Lấy 2 kí tự tiếp theo trong xâu s, bắt đầu từ vị trí i
* RETURN: giá trị số nguyên của 2 chữ số đó.
*/
int Get2Next(char *s, int i)
{
	return (s[i] - '0') * 10 + s[i + 1] - '0';
}

long long Solve(int i)
{
	if(Str[i] == '0') return -1;
	if(Memo[i] != -1) return Memo[i];

	int t = Get2Next(Str, i);

	if(t == 10 || t == 20)
		return Memo[i] = Solve(i + 2);

	if(t <= 26)
	{
		long long t1 = Solve(i + 1);
		long long t2 = Solve(i + 2);

		// Kiểm tra xem t1, t2 cái nào hợp lệ.
		if(t1 == -1 && t2 != -1) return Memo[i] = Solve(i + 2);
		if(t1 != -1 && t2 == -1) return Memo[i] = Solve(i + 1);
		if(t1 == -1 && t2 == -1) return -1;
		return Memo[i] = Solve(i + 1) + Solve(i + 2);
	}
	return Memo[i] = Solve(i + 1);
}

int main(int argc, char** argv)
{
	//freopen("input.txt", "r", stdin);
	ios::sync_with_stdio(false);
	while(true)
	{
		cin >> Str;
		if(Str[0] == '0') break;
		Leng = GetLeng(Str);

		for(int i = 0; i < Leng; i++)
			Memo[i] = -1;

		if(Str[Leng-1] != '0') Memo[Leng-1] = 1;

		// Nếu 2 chữ cái đầu tiên có giá trị <= 26 thì tính đến 2 kí tự
		// Ta có hai cách: ví dụ: 25
		// Có 2 cách giải mã là: BE hoặc Y
		int t = Get2Next(Str, Leng-2);

		if(t > 26 || t == 10 || t == 20) Memo[Leng-2] = 1;
		else Memo[Leng-2] = 2;

		// Print the answer to standard output(screen).
		cout << Solve(0) << endl;
	}
	return 0;//Your program should return 0 on normal termination.
}

SPOJ.COM - Thuật toán bài STPAR - Street Parade

admin@phamvanlam.com — Fri, 28 Oct 2016 22:04:00 GMT

Đề bài:

Để đảm bảo rằng chiếc xe diễu hành sẽ hoạt động trở lại vào mùa hè, mỗi năm ban tổ chức quyết định một thứ tự xác định trước cho việc trang trí những chiếc xe. Kinh nghiệm dạy họ rằng nên giữ một cạnh trống để có thể đưa những chiếc xe vào theo đúng thứ tự.

Đường bên cạnh là rất nhỏ. Vì vậy, 2 chiếc xe không thể cùng vượt qua. Do đó, những chiếc xe nào vào sau sẽ phải ra trước. Bởi vì các xe đi rất gần nhau nên chúng không thể quay đầu hay vào trở lại. Bạn được cho thứ tự đến của những chiếc xe. Viết chương trình kiểm tra xem các chiếc xe có thể đi vào theo đúng thứ tự mà ban tổ chức quyết định hay không.

Đầu vào

Có nhiều test case. Dòng đầu tiên của mỗi test case là một số n, số lượng của những chiếc xe. Dòng thứ 2 chứa các số từ 1 đến n, sắp xếp theo tứ tự ngẫu nhiên. Tất cả các chữ số được phân cách bởi dấu cách. Những số này biểu diễn thứ tự, mà những chiếc xe đi đến con đường. Số xe là không lớn hơn 1000. Kết thúc của đầu vào là số 0.

Đầu ra

Với mỗi test case , in ra 1 dòng duy nhất là "yes" nếu như thoả mãn, ngược lại thì in ra là "no".

Ví dụ

Đầu vào:

5
5 1 2 4 3 
0

Đầu ra:

yes

Giải thích:

Ban đầu:

Xe có thể thay đổi như sau:

Quá trình kết thúc.

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/STPAR/

Phân tích

Ở đây, mình sẽ dùng ngăn xếp stack để giải quyết bài toán. Bài toán này có thể xếp vào dạng sử dụng thuật toán tham lam Greedy.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 1005;

int Order[MAX]; // Thứ tự ban đầu của những chiếc xe
int Stack[MAX]; // Biểu diễn ngăn xếp stack, tương ứng với đoạn đường bên cạnh
int St_size;    // Độ dài ngăn xếp
int Check;      // Lưu kết quả

int main()
{
	//freopen("input.txt","r",stdin);
	int N = 0;
	while(true)
	{
		// Nhập đầu vào là số lượng xe
		cin >> N;
		if(N == 0) break;

		for(int i = 0; i < N; i++)
			cin >> Order[i];
		St_size = 0;
		Check = true;

		// Chỉ số xe có thể đi, ban đầu có giá trị 1
		int start = 1;

		// Duyệt từng xe
		for(int i = 0; i < N; i++)
		{
			// Kiểm tra xem nếu đỉnh ngăn xếp có giá trị start thì cho đi
			while(St_size > 0 && Stack[St_size-1] == start)
			{
				St_size--;
				start++;
			}

			// Nếu đầu dãy là start thì cho đi, tăng start lên 1 đơn vị
			if(Order[i] == start) start++;
			else if (St_size > 0 && Stack[St_size-1] < Order[i])
			{
				// Nếu trường hợp này xảy ra thì chắc chắn sẽ không thoả mãn.
				// Vì trường hợp này ta sẽ phải cho điểm ở đầu dãy vào ngăn xếp
				// Mà sau khi cho xong thì tồn tại 1 điểm có giá trị nhỏ hơn
				// (ưu tiên cao hơn)
				// điểm ở đầu ngăn xếp, mà nó lại không thể đi ra được.
				Check = false;
				break;
			}
			else // Cho điểm đầu của dãy vào ngăn xếp.
			{
				Stack[St_size] = Order[i];
				St_size++;
			}
		}

		if(Check) cout << "yes" << endl;
		else cout << "no" << endl;
	}
	return 0;
}

Code Python:

MAX = 1005
stack = [0] * MAX

while(1):
    n = int(raw_input())
    if n == 0:
        break

    order = map(int, raw_input().split())

    st_size = 0
    check = 1
    start = 1

    for i in range(0, n):
        while (st_size > 0 and stack[st_size - 1] == start):
            st_size -= 1
            start += 1

        if order[i] == start :
            start += 1
        elif st_size > 0 and stack[st_size - 1] < order[i]:
            check = 0
            break
        else:
            stack[st_size] = order[i]
            st_size += 1

    if check == 1:
        print "yes\n"
    else:
        print "no\n"

SPOJ.COM - Thuật toán bài SUMPRO - SUM OF PRODUCT

admin@phamvanlam.com — Fri, 28 Oct 2016 21:47:00 GMT

Đề bài:

Cho trước 1 số N, tìm ra tổng của tất cả các tích x*y trong đó N/x = y (phép chia nguyên). Bởi vì tổng có thể rất lớn, nên chia kết quả cho 1000000007.

Đầu vào

Dòng đầu tiên của đầu vào là một số nguyên T, là số test case. Các dòng tiếp theo, mỗi dòng bao gồm 1 số nguyên N.

Đầu ra

Với mỗi test case in ra kết quả tương ứng.

Ví dụ

Đầu vào:

Đầu ra:

4
15
33

Ràng buộc:

1 <= T <= 500 1 <= N <= 10⁹

Giải thích ví dụ

Ví dụ 1:

2 / 1 = 2
2 / 2 = 1
Answer = 1 * 2 + 2 * 1 = 4

Ví dụ 2:

4 / 1 = 4
4 / 2 = 2
4 / 3 = 1
4 / 4 = 1
Answer = 1 * 4 + 2 * 2 + 3 * 1 + 4 * 1 = 15

Ví dụ 3:

6 / 1 = 6
6 / 2 = 3
6 / 3 = 2
6 / 4 = 1
6 / 5 = 1
6 / 6 = 1
Answer = 1 * 6 + 2 * 3 + 3 * 2 + 4 * 1 + 5 * 1 + 6 * 1 = 33

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/SUMPRO/

Phân tích

Nếu làm thông thường, chắc chắn bạn sẽ bị time limit. Ở đây, mình áp dụng thuật toán tham lam Greedy, sẽ giúp giải quyết bài toán nhanh hơn.

Bạn để ý rằng: với các số chia từ 1 đến sqrt(n) (căn bậc hai của n) thì giá trị thương số chỉ là 1 giá trị duy nhất, không bị lặp lại. Tuy nhiên, từ đó trở đi, giá trị thương số sẽ bị lặp lại.

Trong ví dụ 3, ta có thể tính kết quả theo cách khác là:

Answer = 1 * 6 + 2 * 3 + 3*2 + (4 + 5 + 6) * 1 = 33

Trong đó có một cụm số liên tiếp tăng dần là 4 + 5 + 6

Nếu tính toán với số n lớn hơn thì trong kết quả sẽ chứa nhiều cụm số liên tiếp hơn. Mà áp dụng công thức đối với cấp số cộng ta có: a[1] + a[2] + ... + a[n] = (a[n] - a[1] + 1) _ (a[n] + a[1]) / 2 với công sai d = 1. Ví dụ: 1 + 2 + 3 + 4 + 5 = (5 - 1 + 1) _ (5 + 1) / 2 = 15

Như vậy, thời gian chạy bài toán sẽ nhanh hơn rất nhiều.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

#define ull unsigned long long

const int LARGE = 1000000007;

/*
* Tổng các số từ start đến end công sai d = 1
*/
ull Sum(ull start, ull end)
{
	ull num = end - start + 1;
	return num * (start + end) / 2;
}

int main()
{
	//freopen("input.txt","r",stdin);
	int T;
	cin >> T;

	for(int tc = 0; tc < T; tc++)
	{
		// Nhập đầu vào
		ull N;
		cin >> N;

		ull answer = 0, k;

		// Tính toán bình thường với số chia
		// từ 1 đến căn bậc hai của N
		for(k = 1; k*k <= N; k++)
			answer += k * (N / k);

		// Từ đây giá trị thương số của N / x sẽ bị lặp lại
		// Các bạn chịu khó viết thử một vài trường hợp ra
		// sẽ thấy quy luật.
		ull x = k - 1;
		for(ull i = N / x; i > 1; i--)
		{
			ull y = N / (i-1);
			answer += Sum(x+1,y) * (i-1);
			x = y;
		}

		cout << answer % LARGE << endl;
	}
	return 0;
}

SPOJ.COM - Thuật toán bài TEST - Life, the Universe, and Everything

admin@phamvanlam.com — Wed, 26 Oct 2016 22:00:00 GMT

Đề bài:

Chương trình của bạn là để sử dụng thuật toán vét cạn brute-force để tìm ra câu trả lời cho Life, the Universe, and Everything. Nói đúng hơn, hãy viết những số nhỏ từ đầu vào ra đầu ra. Quá trình dừng lại khi sau khi đọc được số 42.

Đầu vào

Tất cả những số đầu vào là những số nguyên có 1 hoặc 2 chữ số.

Đầu ra

In ra những số mà trước khi gặp số 42 ở đầu vào.

Ví dụ

Đầu vào:

Đầu ra:

1
2
88

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/TEST/

Phân tích

Bài toán này chỉ là một bài toán đơn giản, có thể xếp loại vào dạng sử dụng thuật toán tham lam Greedy

Lời giải

Code C/C++

#include <iostream>
using namespace std;
int main()
{
	//freopen("input.txt","r",stdin);
	int i = -1;
	while(true)
	{
		cin >> i;
		if(i == 42) break;
		cout << i << endl;
	}
	return 0;
}

Code Python:

while(1):
    x = input()
    y = int(x)
    if y == 42:
        break
    print y

SPOJ.COM - Thuật toán bài TOANDFRO - To and Fro

admin@phamvanlam.com — Wed, 26 Oct 2016 21:47:00 GMT

Đề bài:

Mo và Larry đã nghĩ ra cách để mã hoá tin nhắn. Đầu tiên họ bí mật về số lượng cột và viết tin nhắn (chỉ bao gồm các chữ cái) theo từng cột từ trên xuống theo số cột đó, và chèn thêm các kí tự ngẫu nhiên để tạo ra một mảng hình chữ nhật của các chữ cái. Ví dụ: nếu tin nhắn là "There's no place like home on a snowy night" và họ có 5 cột. Thì Mo sẽ viết nó xuống thành:

t o i o y 
h p k n n 
e l e a i 
r a h s g 
e c o n h 
s e m o t 
n l e w x

Chú ý rằng: Mo chỉ viết chữ cái, và ở dạng chữ thường. Ở ví dụ này, Mo sử dụng kí tự 'x' để điền thêm vào tin nhắn để tạo ra mảng kí tự hình chữ nhật. Sau đó Mo gửi tin nhắn đó cho Larry bằng cách viết các chữ này theo mỗi hàng. Lần lượt từ trái sang phải rồi từ phải sang trái. Do đó, tin nhắn trên sẽ thành:

toioynnkpheleaigshareconhtomesnlewx

Nhiệm vụ của bạn là khôi phục lại lá thư gốc cho Larry (kèm theo các chữ cái được thêm vào)

Đầu vào

Bao gồm nhiều test case. Mỗi test case bao gồm 2 dòng. Dòng đầu tiên bao gồm số nguyên từ 2 đến 20, xác định số cột. Dòng tiếp theo là một chuỗi kí tự tối đa là 200 chữ cái thường. Cuối cùng của đầu vào là một dòng chứa số 0.

Đầu ra

Mỗi đầu ra chứa 1 dòng, là tin nhắn gốc của MO, trong đó không chứa dấu cách.

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/TOANDFRO/

Phân tích

Bài toán này không cần phải sử dụng thuật toán gì phức tạp. Do đó, mình xếp nó vào dạng thuật toán tham lam Greedy
Mình sẽ làm bài toán này hoàn toàn dựa theo yêu cầu bài toán. Tức là đề bài nói sao thì mình làm vậy.

Lời giải

Code C/C++:

#include <iostream>
using namespace std;

int main()
{
	//freopen("input.txt","r",stdin);
	int NUM_COL = 0;
	while(true)
	{
	    // Nhập số lượng cột
		cin >> NUM_COL;
		if(NUM_COL == 0) break;

		// Xâu đầu vào
		char str[201];
		cin >> str;

		// Tính độ dài của xâu
		int length = 0;
		while(str[length] != '\0') length++;

		// Lưu ma trận
		char Mat[101][21];

	    // Lưu toạ độ hàng và cột đang đứng
		int col = 0, row = 0;

		// biến thiên chỉ số cột: = 1 nếu đi từ trái sang phải
		// ngược lại = -1
		int delta = 1;

		// Duyệt xâu để chuyển xâu thành ma trận
		for(int i = 0; i < length; i++)
		{
			// Ban đầu là đi từ trái sang phải => chỉ số cột tăng
			Mat[row][col] = str[i];
			col += delta;

			// Khi đi đến cuối thì quay về trái
			if(col >= NUM_COL)
			{
				Mat[row][col] = '\0';
				row++;
				Mat[row][col] = '\0';
				delta = -1;
				col += delta;
			}
			else if (col < 0)	// Khi đi đến đầu thì quay sang bên phải
			{
				row++;
				delta = 1;
				col += delta;
			}
		}

		// Tìm ra kết quả
		int count = 0;
		for(int j = 0; j < NUM_COL; j++)
		{
			for(int i = 0; i < row; i++)
				str[count++] = Mat[i][j];
		}
		str[count] = '\0';
		cout << str << endl;
	}
	return 0;
}

Code Python:

while(1):
    # Nhap so luong cot
    num_col = int(raw_input())
    if num_col == 0:
        break

    # Xau dau vao
    str_input = raw_input()

    # Tinh so luong cot
    num_row = len(str_input) / num_col;

    # Chuyen xau dau vao thanh dang ma tran
    # va luu dang xau binh thuong
    string = ""
    for i in range(0, num_row):
        if i % 2 == 0:
            string += str_input[i*num_col : (i+1)*num_col]
        else:
            string += (str_input[i*num_col : (i+1)*num_col])[::-1]# dao nguoc xau

    # xau ket qua
    result = ""
    for j in range(0, num_col):
        for i in range(0, num_row):
            result += string[i*num_col + j]

    print result

SPOJ.COM - Thuật toán bài WILLITST - Will it ever stop

admin@phamvanlam.com — Wed, 26 Oct 2016 21:33:00 GMT

Đề bài:

Khi Bob đang ở trong thư viện của trường đại học Warsaw, anh ta nhìn thấy một đầu đề ở mặt chính ngôi nhà là "Will it ever stop?" và phía dưới là đoạn code huyền bí:

while n > 1
  if n mod 2 = 0 then
    n := n/2
  else
    n := 3*n+3

Hãy giúp anh ấy tìm ra lời giải đáp.

Đầu vào

Một dòng chứa một số n với n <= 10^14

Đầu ra

In ra "TAK" nếu chương trình có dừng lại, ngược lại thì in ra "NIE"

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/WILLITST/

Phân tích

Ở đây, mình sử dụng thuật toán tham lam Greedy
Rõ ràng vòng lặp dừng lại khi n <= 1. Mà điều này chỉ xảy ra khi số n được biểu diễn dưới dạng 2^k, Khi đó, sau k vòng lặp kết quả sẽ được n == 1. Và khi đó vòng lặp sẽ bị thoát.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

typedef unsigned long long ull;

int main()
{
	//freopen("input.txt","r",stdin);
	ull n = 0;
	cin >> n;
	bool checkStop =  true;
	while(true)
	{
		if(n <= 2) break;

		// Nếu số n có một ước số > 2 mà lẻ thì chắc chắn
		// ở trong vòng lặp đề bài n = 3*n + 3 , n sẽ tăng
		// do đó vòng lặp đó sẽ không bao giờ dừng
		if(n > 2 && n%2 != 0)
		{
			checkStop = false;
			break;
		}
		n = n/2;
	}
	if(checkStop) cout << "TAK" << endl;
	else cout << "NIE" << endl;
	return 0;
}

Code Python:

n = long(input())
checkStop = 1

while(1):
    if n <= 2:
        break
    if (n > 2 and n%2 != 0):
        checkStop = 0
        break
    n = n/2

if checkStop == 1 :
    print "TAK\n"
else:
    print "NIE\n"

SPOJ.COM - Thuật toán bài TDPRIMES - Printing some primes

admin@phamvanlam.com — Sun, 23 Oct 2016 21:31:00 GMT

Đề bài:

Yêu cầu của bài toán vô cùng đơn giản. Hãy in ra tất cả số nguyên tố nhỏ hơn 10^8.

Đầu vào

Không có đầu vào

Đầu ra

Để giúp cho bài toán có ít kết quả hơn, hãy in ra tất cả số nguyên tố thứ 1, 101, 201,...(những số chia cho 100 thì dư 1).

Ví dụ

Đầu vào:

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/TDPRIMES/

Phân tích

Bài này mình xếp vào loại sử dụng thuật toán tham lam Greedy

Ở đây, nếu suy nghĩ theo cách thông thường, chắc hẳn bạn sẽ viết một hàm kiểm tra xem 1 số có phải số nguyên tố hay không. Sau đó, duyệt từ 1 cho đến 10^8 để kiểm tra từng số xem nó có phải số nguyên tố hay không. Rồi in ra những số nguyên tố thứ 1, 101, 201,... Tuy nhiên, nếu làm theo cách này chắc chắn bạn sẽ bị time limit.

Đối với bài toán này, mình sử dụng phương pháp sàng Eratosthenes để tìm ra các số nguyên tố.

Để tìm các số nguyên tố nhỏ hơn hoặc bằng số tự nhiên N bằng sàng Eratosthenes, ta làm như sau:

Bước 1: Tạo 1 danh sách các số tự nhiên liên tiếp từ 2 đến n: (2, 3, 4,..., n).
Bước 2: Giả sử tất cả các số trong danh sách đều là số nguyên tố. Trong đó, p = 2 là số nguyên tố đầu tiên.
Bước 3: Tất cả các bội số của p: 2p, 3p, 4p,... sẽ bị đánh dấu vì không phải là số nguyên tố. -
Bước 4: Tìm các số còn lại trong danh sách mà chưa bị đánh dấu và phải lớn hơn p. Nếu không còn số nào, dừng tìm kiếm. Ngược lại, gán cho p giá trị bằng số nguyên tố tiếp theo và quay lại bước 3.

Lời giải

Code C/C++

#include<stdio.h>
using namespace std;

const int MAX = 100000000;
bool prime[MAX];// Đánh dấu xem số i có phải là số nguyên tố không

int main()
{
	for(int i = 2; i < MAX; i++)
		prime[i] = true;

	// Số nguyên tố đầu tiên là số 2
	printf("2\n");

	int cnt_prime = 1;	// Đếm số nguyên tố

	// Dùng phương pháp sàng để đánh dấu các số nguyên tố.
	// Số chẵn lớn hơn 2 chắc chắn không phải là số nguyên tố.
	// Nên ta chỉ cần kiểm tra số lẻ.
	// Nguyên tắc: nếu số i là số nguyên tố => 3*i, 5*i, 7*i,...
	// không phải số nguyên tố
	int i;
	for(i = 3; i*i < MAX; i=i+2)
		if(prime[i])
		{
			cnt_prime++;
			if(cnt_prime % 100 == 1) printf("%d\n",i);

			int j = 3;
			while(i*j < MAX)
			{
				prime[i*j] = false;
				j += 2;
			}
		}

	// In ra số nguyên tố còn lại
	for(int j = i; j < MAX; j+=2)
		if(prime[j])
		{
			cnt_prime++;
			if(cnt_prime % 100 == 1) printf("%d\n",j);
		}

	return 0;
}

SPOJ.COM - Thuật toán bài TRAFFICN - Traffic Network

admin@phamvanlam.com — Sun, 23 Oct 2016 20:44:00 GMT

Đề bài:

Mạng lưới giao thông thành phố gồm n nút được đánh số từ 1 đến n và m đường một chiều nối các cặp nút. Để giảm được độ dài của đường đi ngắn nhất giữa hai nút trọng yếu s và t khác nhau, một danh sách gồm k đường hai chiều được đề xuất để xem xét xây dựng.

Nhiệm vụ của bạn là viết một chương trình để chọn ra một đường trong danh sách đề xuất trên để xây dựng sao cho độ dài đường đi ngắn nhất giữa s và t là nhỏ nhất.

Đầu vào

Dữ liệu vào gồm nhiều bộ dữ liệu tương ứng với nhiều test. Dòng đầu tiên chứa một số nguyên dương không lớn hơn 20 là số lượng các bộ dữ liệu. Các dòng tiếp theo chứa các bộ dữ liệu.

Với mỗi bộ dữ liệu, dòng đầu tiên chứa năm số nguyên dương n (n ≤ 10 000), m (m ≤ 100 000), k (k < 300), s (1 ≤ s ≤ n), t (1 ≤ t ≤ n) cách nhau bởi dấu trống.

Dòng thứ i trong m dòng tiếp theo chứa ba số nguyên dương di, ci, li cách nhau bởi dấu trống, trong đó li là độ dài ( 0< li ≤ 1000) của đường một chiều thứ i từ nút di đến nút ci.

Dòng thứ j trong k dòng tiếp theo chứa ba số nguyên dương uj, vj và qj (qj ≤ 1000) cách nhau bởi dấu trống, trong đó qj là độ dài của đường hai chiều được đề xuất thứ j nối giữa hai nút uj và vj.

Đầu ra

Với mỗi bộ dữ liệu, ghi ra trên một dòng độ dài nhỏ nhất có thể của đường đi ngắn nhất giữa hai nút trọng yếu sau khi xây dựng xong một đường hai chiều từ danh sách đề xuất. Trường hợp không có đường đi từ s đến t, ghi -1.

Ví dụ

Đầu vào:

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/TRAFFICN/en/

Phân tích

Trong bài toán này mình sẽ sử dụng thuật toán Dijkstra để tìm đường đi ngắn nhất từ điểm s tới tất cả các điểm còn lại và tìm đường đi ngắn nhất từ tất cả các điểm còn lại đến điểm t.

Sau đó mình sẽ duyệt các con đường trong k con đường dự kiến cần thay thế. Giả sử 1 con đường từ a đến b và khoảng cách của nó là c. Khi đó, đường đi ngắn nhất của a và b sẽ bằng: Min{kc(s, a) + c + kc(b, t), kc(s, b) + c + kc(a, t)}

Trong đó:

kc(s, a) là khoảng cách đường đi ngắn nhất từ s tới a (tương tự với b)
kc(b, t) là khoảng cách đường đi ngắn nhất từ b tới t (tương tự với a).

Sau khi duyệt hết k con đường ta sẽ tìm được giá trị cần tính.

Chú ý:

ở đây, do số lượng điểm và số con đường rất lớn nên ta không thể dùng ma trận kề được. Ở đây, mình dùng danh sách liên kết.
Đối với thuật toán Dijkstra, nếu muốn sử dụng thư viện, bạn có thể sử dụng thư viện hàng đợi ưu tiên (trong c++ hàng đợi ưu tiên là priority_queue nằm trong thư viện <queue>). Ở đây, mình sẽ triển khai (implement) lại hàng đợi ưu tiên sử dụng kỹ thuật vun đống. Nếu bạn sử dụng cách khác thì khả năng time limit là vô cùng cao.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX_INT = 1000000000;
const int MAX = 10005;
const int MAX_QUEUE = 100000;

/*************Node biểu diễn một điểm***************/
typedef struct Node
{
	int id, leng;
	Node *next;

	Node():id(0), leng(0){}
	Node(int _id, int _leng):id(_id), leng(_leng){}
}Node;
/**************************************************/

/**************Danh sách liên kết******************/
class List
{
public:
	Node *front;
public:
	List():front(0){}

	void Add(int id, int leng)
	{
		Node *tmp = new Node;

		tmp->id = id;
		tmp->leng = leng;
		tmp->next = front;

		front = tmp;
	}
};
/****************************************************/

int n, m, k, s, t, Answer;

bool Visit[2][MAX];
int  d[2][MAX];
//d[0] lưu khoảng cách ngắn nhất từ điểm s tới các điểm còn lại
//d[1] lưu khoảng cách ngắn nhất từ các điểm còn lại tới t

List Link[2][MAX];
//Link[0] lưu trạng thái đồ thị ban đầu
//Link[1] lưu trạng thái của đồ thị khi bị đảo ngược.

int leng;
Node Queue[MAX_QUEUE];

void Swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}

/**********Triển khai hàng đợi ưu tiên dùng vun đống****************/
void Heapify(int leng, int i)
{
	int Left = 2*i + 1, Right = 2*i + 2;
	int Smallest;

	if (Left < leng && Queue[Left].leng < Queue[i].leng) Smallest = Left;
	else Smallest = i;

	if (Right < leng && Queue[Right].leng < Queue[Smallest].leng) Smallest = Right;

	if (Smallest != i)
	{
		Swap(Queue[i].leng,Queue[Smallest].leng);
		Swap(Queue[i].id,Queue[Smallest].id);
		Heapify(leng,Smallest);
	}
}

// Thêm phần tử vào cuối hàng đợi
void Enqueue(Node node)
{
	Queue[leng++] = node;

	if(leng >= 2)
	{
		int current = leng - 1;
		int parent  = (current - 1)/2;

		while (current > 0)
		{
			if(Queue[current].leng < Queue[parent].leng)
			{
				Swap(Queue[current].leng, Queue[parent].leng);
				Swap(Queue[current].id, Queue[parent].id);

				current = parent;
				parent = (current - 1)/2;
			}
			else break;
		}
	}
}

// Lấy ra phần tử ở đầu hàng đợi.
Node Dequeue()
{
	Node t = Queue[0];

	Queue[0].id = Queue[leng-1].id;
	Queue[0].leng = Queue[leng-1].leng;

	leng--;

	Heapify(leng,0);

	return t;
}
/******************************************************/

/*******Thuật toán Dijkstra tìm đường đi ngắn nhất*****/
void Dijkstra(int start, int type)
{
	d[type][start] = 0;

	leng = 0;
	Enqueue(Node(start,0));

	while(leng > 0)
	{
		Node node = Dequeue();

		if(Visit[type][node.id]) continue;
		Visit[type][node.id] = true;

		Node *p = Link[type][node.id].front;

		while(p != 0)
		{
			if(d[type][node.id] + p->leng < d[type][p->id])
			{
				d[type][p->id] = d[type][node.id] + p->leng;
				Enqueue(Node(p->id,d[type][p->id]));
			}

			p = p->next;
		}
	}
}
/*************************************************************/

int main()
{
	ios::sync_with_stdio(false);
//	freopen("input.txt","r",stdin);

	int T;
	cin >> T;

	for(int tc = 0; tc < T; tc++)
	{
		Answer = 0;
		cin >> n >> m >> k >> s >> t;

		for(int i = 0; i <= n; i++)
		{
			for(int k = 0; k < 2; k++)
			{
				Link[k][i].front = 0;
				Visit[k][i] = false;
				d[k][i] = MAX_INT;
			}
		}

		int a, b, c;

		for(int i = 0; i < m; i++)
		{
			cin >> a >> b >> c;

			Link[0][a].Add(b,c);
			Link[1][b].Add(a,c);
		}

		// Tìm đường đi ngắn nhất từ s tới các điểm còn lại
		Dijkstra(s,0);
		Answer = d[0][t];

		// Tìm đường đi ngắn nhất từ mọi điểm đến điểm t
		Dijkstra(t,1);

		// Tìm đường đi ngắn nhất
		for(int i = 0; i < k; i++)
		{
			cin >> a >> b >> c;

			if(d[0][a] + c + d[1][b] < Answer) Answer = d[0][a] + c + d[1][b];
			if(d[0][b] + c + d[1][a] < Answer) Answer = d[0][b] + c + d[1][a];
		}

		if(Answer == MAX_INT) Answer = -1;

		cout << Answer << endl;
	}

	return 0;
}

SPOJ.COM - Thuật toán bài ZIGZAG - Zig-Zag rabbit

admin@phamvanlam.com — Thu, 20 Oct 2016 21:58:00 GMT

Đề bài:

Một ma trận kích thước NxN được điền đầy bởi các con số từ 1 đến N² theo đường chéo zig-zag. Bảng sau đây mô tả những con số trong ma trận kích thước N = 6.

Có một con thỏ ở vị trí số 1. Nó có thể nhảy sang ô hàng xóm kề với ô nó đang đứng theo 4 hướng (trên, dưới, trái, phải) nếu ô đó tồn tại.

Cho K chữ cái biểu diễn cách nhảy của con thỏ. Hãy viết chương trình tính tổng các số của tất cả các ô mà con thỏ nhảy tới. Biết con thỏ không bao giờ nhảy ra khỏi ma trận.

Đầu vào

Dòng đầu tiên bao gồm 2 số nguyên N và K (1 <= N <= 100000, 1 <= K <= 300000), lần lượt là kích thước ma trận và số bước nhảy của con thỏ.

Dòng tiếp theo là 1 dãy bao gồm K kí tự 'U', 'D', 'L' và 'R', miêu tả cách nhảy của con thỏ. Trong đó, 'U', 'D', 'L','R' lần lượt là nhảy lên (UP), nhảy xuống (DOWN), nhảy sang trái (LEFT) và nhảy sang phải (RIGHT). Và con thỏ sẽ không nhảy ra khỏi ma trận.

Đầu ra

Bao gồm 1 dòng chứa 1 số nguyên là tổng của tất cả những ô mà con nhỏ nhảy tới.

Chú ý: Các số không phải luôn thỏa mãn là số nguyên 32 bit.

Ví dụ

1) Đầu vào:

6 8 
DDRRUULL

Đầu ra:

Giải thích: con thỏ nhảy như sau: 1, 3, 4, 9, 13, 8, 6, 2, 1

2) Đầu vào:

3 8 
DDRRUULL

Đầu ra:

Giải thích: con thỏ nhảy như sau: 1, 3, 4, 8, 9, 7, 6, 2, 1

3) Đầu vào:

6 10 
RRRRRDDDDD

Đầu ra:

Giải thích: con thỏ nhảy như sau: 1, 2, 6, 7, 15, 16, 26, 27, 33, 34, 36

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/ZIGZAG/

Phân tích

Mình sẽ sử dụng thuật toán tham lam - Greedy để giải bài toán này.

Ở đây mình sẽ không sử dụng một mảng để lưu thông tin của ma trận. Vì việc tạo ra ma trận này là rất mất thời gian. Nếu bạn để ý thì bạn sẽ nhận ra được quy luật. Qua đó, từ tọa độ hàng, cột mình có thể suy ra giá trị của ô đó là bao nhiêu.

Với ma trận kích thước N thì sẽ có 2*N-1 đường chéo (có dạng '/'). Mỗi đường chéo sẽ bao gồm các ô mà tổng giá trị hàng và cột của chúng là như nhau và mình đặt là chỉ số của đường chéo.

Ví dụ:

Đường chéo 0 chỉ bao gồm 1 phần tử [0][0]
Đường chéo 1 bao gồm 2 ô là [0][1] và [1][0]
Đường chéo 2 bao gồm 3 ô là: [0][2], [1][1] và [2][0],
... cho đến đường chéo 2*N-2 bao gồm 1 ô là [N-1][n-1].

Sử dụng quy nạp mình chứng minh được công thức tính số nhỏ nhất của 1 đường chéo như sau:

Với i là chỉ số đường chéo (i = 0, 1, 2,...,2*N-2), k là số nhỏ nhất của 1 đường chéo.
Nếu i < N thì k = (1 + (i*(i+1))/2);
Ngược lại, k = (((3*N - i)*(i - N + 1))/2 + remember)
Trong đó, remember là số nhỏ nhất của đường chéo ở giữa (chỉ số N - 1)

Rõ ràng, khi mình đã biết chỉ số hàng, cột của một điểm và số nhỏ nhất của đường chéo mà điểm đó thuộc vào thì mình hoàn toàn có thể tính được giá trị của điểm đó (cụ thể mình sẽ trình bày ở trong code phía dưới).

Lời giải

Code C/C++

#include<iostream>
using namespace std;

typedef unsigned long long ull;
const ull MAX = 300005;

ull N, K;
ull remember;
char Str[MAX];  // Lưu xâu đầu vào

/*
* Lấy ra số nhỏ nhất của một đường chéo thứ i
* Đường chéo thứ i là đường chéo có tổng chỉ số hàng và cột
* của mỗi ô là bằng i.
* @PARAM : i : chỉ số của đường chéo
* RETURN : giá trị số nhỏ nhất của đường chéo đó.
*/
ull GetMinDiagon(ull i)
{
	if(i < N) return (1 + (i*(i+1))/2);
	return (((3*N - i)*(i - N + 1))/2 + remember);
}

ull GetValue(ull row, ull col)
{
	// Tỉnh tổng chỉ số hàng và cột để suy ra chỉ số đường chéo
	ull sum = row + col;
	// Tính số nhỏ nhất của đường chéo đó.
	ull min_diagon = GetMinDiagon(sum);

	// chỉ số đường chéo là chẵn
	if(sum%2 == 0 && sum < N)
	{
		return min_diagon + col;
	}
	else if(sum%2 == 0 && sum >= N)
	{
		ull col_start = sum - (N-1);
		return min_diagon + (col - col_start);
	}
	// Chỉ số đường chéo là lẻ
	else if(sum%2 == 1 && sum < N)
	{
		return min_diagon + (sum - col);
	}
	else if(sum%2 == 1 && sum >= N)
	{
		return min_diagon + (N-1) - col;
	}
}

int main()
{
	freopen("input.txt","r",stdin);
	ios::sync_with_stdio(false);

	cin >> N >> K >> Str;
	remember = GetMinDiagon(N-1);

	// Khởi tạo vị trí ban đầu là [0][0] và tổng là 1
	ull row = 0, col = 0;
	ull sum = 1;

	// Duyệt từng kí tự để xác định cách nhảy của thỏ
	for(int i = 0; i < K; i++)
	{
		if(Str[i] == 'U') row -= 1;
		else if(Str[i] == 'D') row += 1;
		else if(Str[i] == 'R') col += 1;
		else if(Str[i] == 'L') col -= 1;

		// Cộng dồn các ô mà thỏ nhảy tới.
		sum += GetValue(row, col);
	}

	// In kết quả
	cout << sum << endl;

	return 0;
}

SPOJ.COM - Thuật toán bài NDCCARD - Các lá bài Blackjack

admin@phamvanlam.com — Thu, 20 Oct 2016 21:40:00 GMT

Đề bài:

Blackjack là trò chơi đánh bài khá phổ biến, mục tiêu là có được những lá bài mà tổng của nó là lớn nhất nhưng không vượt quá 21. Lấy ý tưởng từ trò chơi này bạn khaihanhdk huytion156 thanhdat01234 đã sáng tạo ra một phiên bản mới của trò chơi cho riêng mình.

Trong phiên bản trò chơi mới này bạn đã viết lên mỗi lá bài một số nguyên dương. Người tham gia trò chơi được cung cấp một tập gồm N lá bài và một số nguyên dương M. Nhiệm vụ của người chơi là phải chọn ra 3 lá bài từ tập lá bài đã cho sao cho tổng các số trên 3 lá bài đã chọn là lớn nhất và không vượt quá M.

Yêu cầu: Bạn hãy tìm kết quả tốt nhất có thể có của trò chơi trên.

Đầu vào

Dòng đầu ghi số nguyên dương N, M (N <= 10000 , M <= 500000). Dòng sau ghi N số nguyên dương đôi một khác nhau là các số được ghi trên N lá bài ( 1 ≤ a[i] ≤ 10000).

Đầu ra

Ghi trên một dòng duy nhất là kết quả bài toán. Test luôn đảm bảo có kết quả.

Ví dụ

Đầu vào:

6 20 
7 9 6 2 1 5

Đầu ra:

Giải thích:

Chọn các lá bài mang số 9 , 6 , 5 ta có 9+6+5 = 20 <= M

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/NDCCARD/

Phân tích

Yêu cầu tìm ra 3 số có tổng không vượt quá M. Do đó, trong quá trình nhập đầu vào, mình sẽ loại bỏ luôn những số > M.

Ở đây, mình sẽ dùng thuật toán sắp xếp trộn Merge Sort để sắp xếp dãy đầu vào theo thứ tự tăng dần.

Sau đó, mình sẽ duyệt dãy sau khi sắp xếp. Với mỗi cặp 2 số a[i1][j1] và a[i2][j2], mình sẽ sử dụng thuật toán chia để trị - Divide and Conquer để tìm ra số lớn nhất thỏa mãn tổng 3 số không vượt quá M. Sau khi duyệt hết tất cả các trường hợp, mình sẽ tìm được kết quả.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX = 10005;

int N, M;
int a[MAX];
int MaxSum;     // Giá trị tổng lớn nhất không lớn hơn M.
int Leng;       // Số các số < M - 1

// Sắp xếp dùng Merge Sort
void Merge(int *arr, int left, int m, int right)
{
	int *tmp = new int[right - left + 1];
	int l = left, r = m + 1, k = 0;

	while(l <= m && r <= right)
	{
		if(a[l] < a[r]) tmp[k++] = a[l++];
		else tmp[k++] = a[r++];
	}

	while(l <= m) tmp[k++] = a[l++];

	while(r <= right) tmp[k++] = a[r++];

	for(int i = 0; i < k; i++)
		arr[i + left] = tmp[i];

	delete[] tmp;
}

void MergeSort(int *arr, int left, int right)
{
	int m;
	if(left < right)
	{
		m = (left + right) / 2;
		MergeSort(arr, left, m);
		MergeSort(arr, m + 1, right);
		Merge(arr, left, m, right);
	}
}

/*
* Tìm kiếm nhị phân
* Tìm ra số lớn nhất mà không lớn hơn giá trị value
*/
int BinarySearch(int value)
{
	int left = 0, right = Leng - 1;
	int x = 0;

	while(left < right - 1)
	{
		x = (left + right) / 2;
		if(a[x] <= value) left = x;
		else if(a[x] > value) right = x - 1;
	}

	if(a[right] <= value) return right;

	return left;
}

int main()
{
	//freopen("input.txt","r",stdin);
	ios::sync_with_stdio(false);

	// Nhập đầu vào, đồng thời loại bỏ những số lớn hơn hoặc bằng M - 1
	// Vì các số trong dãy >= 1
	MaxSum = Leng = 0;
	cin >> N >> M;
	for(int i = 0; i < N; i++)
	{
		int t = 0;
		cin >> t;
		if(t < M - 1) a[Leng++] = t;
	}

	// Sắp xếp dãy tăng dần
	MergeSort(a, 0, Leng-1);

	// Kiểm tra để dừng sớm
	bool Finish = false;

	// Duyệt mảng
	for(int i = 0; i < Leng; i++)
	{
		for(int j = i + 1; j < Leng; j++)
		{
			int temp = M - (a[i] + a[j]);
			if(temp <= 0){
				Finish = true;
				break;
			}

			// Dùng tìm kiếm nhị phân tìm ra số lớn nhất và không lớn hơn số 'temp'
			// Số tìm được phải khác hai số tại: i và j
			int k = BinarySearch(temp);
			if(k == i || k == j) break;

			int sum = a[k]+ a[i] + a[j];
			if(sum > MaxSum) MaxSum = sum;
		}
		if(Finish) break;
	}

	// In kết quả
	cout << MaxSum << endl;

	return 0;
}

SPOJ.COM - Thuật toán bài CHESSCBG - Bàn cờ thế

admin@phamvanlam.com — Thu, 20 Oct 2016 21:11:00 GMT

Đề bài:

Một bàn cờ thế là một bảng gồm 4 dòng, 4 cột. Mỗi thế cờ là một cách sắp xếp 8 quân cờ, hai quân khác nhau ở hai ô khác nhau. Bài toán đặt ra là cho hai thế cờ 1 và 2, hãy tìm một số ít nhất bước di chuyển quân để chuyển từ thế 1 sang thế 2; một bước di chuyển quân là một lần chuyển quân cờ sang ô trống kề cạnh với ô quân cờ đang đứng.

Đầu vào

Từ file văn bản gồm 8 dòng, mỗi dòng là một xâu nhị phân độ dài 4 mà số 1/0 tương ứng với vị trí có hoặc không có quân cờ. Bốn dòng đầu là thế cờ 1, bốn dòng sau là thế cờ 2.

Đầu ra

Gồm 1 dòng duy nhất là số bước chuyển quân ít nhất.

Ví dụ

Đầu vào:

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://vn.spoj.com/problems/CHESSCBG/

Phân tích

Ở đây, ma trận đầu vào mình sẽ lưu nó dưới dạng mảng 1 chiều. Công thức để quy đổi từ tọa độ 1 điểm trên ma trận thành tọa độ 1 điểm trên mảng và ngược lại như sau:

Từ điểm có tọa độ [r][c] trên ma trận thì tọa độ trên mảng là: r*N + c (trong đó N là số cột của ma trận. Ở đây N = 4). Ví dụ: một điểm ở tọa độ [1][2] (hàng 1, cột 2) thì ở trên mảng nó sẽ tương ứng với điểm 1*4 + 2 = 6 (chỉ số tính từ 0)
Ngược lại, từ một điểm ở trên mảng có tọa độ là t thì ở trên mảng, tọa độ của nó là: c = t % N và r = (t - c)/4. Lấy luôn ví dụ trên, với điểm trên mảng có tọa độ t = 6, thì trên mảng nó sẽ có tọa độ: c = 6 % 4 = 2 và r = (6 - 2) /4 = 1.

Như vậy, thế cờ 1 và thế cờ 2 đều có thể biểu diễn được dưới dạng mảng 1 chiều gồm 16 phần tử. Ở đây, mình sẽ sử dụng thuật toán tìm kiếm theo chiều rộng - BFS với trạng thái đầu là thế cờ 1 và trạng thái đích là thế cờ 2. Để thực hiện điều này, mình cần phải có một mảng để lưu số bước ít nhất mà từ thế cờ 1 tới thế cờ đó.

Ở đây có một điều đặc biệt đó là các phần tử của mảng chỉ bao gồm các số 0 và 1. Do đó, mình hoàn toàn có thể coi nó như là một số nhị phân. Vì vậy, mình sẽ chuyển nó thành số thập phân tương ứng để biểu diễn trạng thái đó. Với ví dụ đầu bài, thế cờ 1 là:

Mình chuyển nó thành mảng: 1111.0000.1110.0010. Dãy số này tương ứng với số: 61666. Đến đây là bài toán đã trở nên đơn giản hơn rồi phải không bạn.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX_INT = 1 << 30;
const int MAX = 100000;

// Mảng lưu giá trị lũy thừa của 2 tại các vị trí.
// Ví dụ tại vị trí 0 - tương ứng với 2^15 = 32768
const int Po2[16] = {32768, 16384, 8192, 4096, 2048, 1024,
                     512, 256, 128, 64, 32, 16, 8, 4, 2, 1};

int MinStep;    // Số bước nhỏ nhất để chuyển từ Map nguồn thành Map đích.
int Init[2];    // Lưu trạng thái của Map đầu và cuối dưới dạng số.
int Mark[MAX];  // Đánh dấu với mỗi trạng thái thì số bước nhỏ nhất là bao nhiêu
int State[16];  // Trạng thái của ma trận.

// Biểu diễn hàng đợi vòng
int queue[MAX];
int fr, re, leng;

void Enqueue(int stt)
{
	queue[re] = stt;
	re = (re + 1) % MAX;
	leng++;
}

int Dequeue()
{
	int stt = queue[fr];
	fr = (fr + 1) % MAX;
	leng--;
	return stt;
}

/*
* @PARAM: value : số đầu vào cần chuyển đổi thành ma trận trạng thái
*/
void ConvertInt2Matrix(int value)
{
	for(int i = 0; i < 16; i++)
	{
		int _c = i % 4;
		int _r = (i - _c) / 4;

		// Kiểm tra xem chữ số nào mà bằng 1 thì cho giá trị ma trận = 1
		// ngược lại là 0
		if((1 << i) & value) State[15 - i] = 1;
		else State[15 - i] = 0;
	}
}

int drow[4] = {-1,0,1, 0};
int dcol[4] = { 0,1,0,-1};

void BFS(int init)
{
	fr = re = leng = 0;
	for(int i = 0; i < MAX; i++)
		Mark[i] = MAX_INT;

	// Trạng thái đầu tiên
	Mark[init] = 0;
	Enqueue(init);

	while(leng > 0)
	{
		int begin = Dequeue();

		// Chuyển giá trị state vào ma trận.
		ConvertInt2Matrix(begin);

		// Duyệt các trạng thái.
		for(int i = 0; i < 16; i++)
			if(State[i] == 1)
			{
				// Tính tọa độ tương ứng trên ma trận
				int _c = i % 4;
				int _r = (i - _c) / 4;

				// Kiểm tra 4 hướng xem với số 1 di chuyển 4 hướng
				// thì trạng thái tiếp theo là gì.
				for(int j = 0; j < 4; j++)
				{
					int r = _r + drow[j];
					int c = _c + dcol[j];

					if(r >= 0 && r < 4 && c >= 0 && c < 4 && State[r*4+c] == 0)
					{
						// Tính giá trị của số mới
						// với việc số 1 ở vị trí ban đầu (_r*4 + _c) chuyển thành 0
						// số 0 ở vị trí (r*4 + c) chuyển thành 1
						int value = begin + Po2[r*4+c] - Po2[_r*4+_c];

						if((Mark[value] == MAX_INT || Mark[value] > Mark[begin] + 1))
						{
							Mark[value] = Mark[begin] + 1;
							Enqueue(value);
						}
					}
				}
			}
	}
}

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);

	// Nhập đầu vào.
	// Convert trạng thái Map thành số nguyên,
	// vì tại mỗi ô của Map chỉ có 2 trạng thái 0, 1.
	for(int k = 0; k < 2; k++)
	{
		Init[k] = 0;
		for(int i = 0; i < 4; i++)
		{
			char temp[5];
			cin >> temp;
			for(int j = 0; j < 4; j++)
				Init[k] = Init[k] * 2 + (temp[j] - '0');
		}
	}

	// BFS từ trạng thái ban đầu cho đến khi gặp trạng thái đích
	BFS(Init[0]);

	// In kết quả
	cout << Mark[Init[1]] << endl;

	return 0;
}

SPOJ.COM - Thuật toán bài NKLETTER - Gửi thư

admin@phamvanlam.com — Tue, 18 Oct 2016 21:15:00 GMT

Đề bài:

Vị Giám đốc công ty XYZ cần gửi một văn bản quan trọng tới một đối tác của mình. Văn bản là một xâu S các chữ cái la tinh in thường. Để bảo mật nội dung văn bản, ông Giám đốc gửi 2 bức thư. Bức thư thứ nhất là phần đầu Sb của xâu S, bức thư thứ 2 là phần cuối Se của S. Hai bức thư Sb và Se đảm bảo đầy đủ nội dung của S, tuy nhiên có thể một phần cuối của Sb có thể được viết lặp lại trong phần đầu của Se, song số kí tự được viết lặp lại không biết trước.

Ví dụ: với văn bản S = 'truongnguyenduquannhat' tạo ra hai bức thư:

Sb = truongngueNdu

ngueNduquanNhat = Se

Sb = 'truongnguyendu' và Se = 'nguyenduquannhat'

Yêu cầu: Cho hai xâu Sb và Se, hãy xác định một xâu S có thể là nội dung của bức thư sao cho độ dài của xâu S là ngắn nhất.

Đầu vào

Dòng đầu chứa xâu Sb, dòng thứ hai chứa xâu Se. Mỗi xâu có độ dài không quá 250.

Đầu ra

Ghi ra độ dài của xâu S tìm được.

Ví dụ:

Đầu vào:

truongnguyendu 
nguyenduquannhat

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://vn.spoj.com/problems/NKLETTER/

Phân tích

Trong bài toán này mình sẽ sử dụng thuật toán tham lam - Greedy để giải quyết.

Tử tưởng chính là mình sẽ duyệt từ đầu đến cuối xâu SB. Với mỗi vị trí đó, mình sẽ so sánh thành phần từ vị trí đó đến cuối xâu của xâu SB với thành phần có độ dài tương ứng tính từ đầu mảng của SE.

Đến khi mình tìm được vị trí thỏa mãn đầu tiên, thì đó chính là thành phần trùng nhau của hai xâu thỏa mãn cho xâu S có độ dài nhỏ nhất.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX = 505;
char SB[MAX], SE[MAX];  // Xâu đích S, xâu đầu SB và xâu cuối SE
int  LengB, LengE;      // Độ dài tương ứng của SB và SE.

/*
* Tính độ dài xâu
* @PARAM: str : xâu cần tính độ dài
* RETURN: độ dài xâu
*/
int GetLeng(char *str)
{
	int leng = 0;
	while(str[leng] != '\0') leng++;
	return leng;
}

/*
* Kiểm tra với với vị trí pos trên SB như vậy có thoả mãn hay không
* @PARAM: pos : vị trí đang xét trên SB.
* RETURN: true nếu hợp lệ, ngược lại là false
*/
bool IsValid(int pos)
{
	int leng1 = LengB - pos;
	if(leng1 > LengE) return false;

	for(int i = 0; i < leng1; i++)
		if(SB[pos + i] != SE[i]) return false;

	return true;
}

int main()
{
	//freopen("input.txt","r",stdin);
	ios::sync_with_stdio(false);

	// Nhập đầu vào
	cin >> SB >> SE;

	LengB = GetLeng(SB);
	LengE = GetLeng(SE);

	// Duyệt xâu SB từ đầu. Tại mỗi vị trí ta sẽ kiểm tra
	// thành phần cuổi của SB với thành phần đầu tương ứng của SE
	// - cùng độ dài. Nếu chúng giống nhau thì dừng lại.
	int pos = 0;
	for(pos = 0; pos < LengB; pos++)
		if(IsValid(pos)) break;

	int MinLen = pos + LengE;

	// In đầu ra
	cout << MinLen << endl;

	return 0;
}

SPOJ.COM - Thuật toán bài PIZZALOC - Pizza Location

admin@phamvanlam.com — Mon, 17 Oct 2016 21:04:00 GMT

Đề bài:

Picko muốn mở một số cửa hàng pizza tại 1 số địa điểm. Bánh pizza sẽ cung cấp cho mọi khách hàng nằm trong hình tròn bán kính R với tâm là các địa điểm được chọn.

Xác định số khách hàng lớn nhất có thể phục vụ.

Input

Dòng đầu là hai số K, R : số nhà hàng có thể được mở và bán kính phục vụ của mỗi nhà hàng,1 ≤ K ≤ 10, 1 ≤ R ≤ 500.

Dòng thứ hai là M, số địa điểm có thể đặt nhà hàng, K ≤ M ≤ 20.

M dòng tiếp theo, mỗi dòng là 2 số nguyên X và Y, -1000 ≤ X,Y ≤ 1000.

Dòng tiếp theo là N, số khu nhà, 1 ≤ N ≤ 100.

Mỗi dòng trong N dòng tiếp theo là 3 số nguyên X, Y , S, là tọa độ và số người ở khu nhà đó, -1000 ≤ X,Y ≤ 1000, 1 ≤ S ≤ 100.

Khu nhà nằm trong bán kính của nhà hàng nếu khoảng cách giữa chúng <= R. Không có 2 khu nhà tại cùng 1 địa điểm.

Output

Ghi ra số người tối đa có thể được phục vụ.

Ví dụ

pizza.in

pizza.out

pizza.in

pizza.out

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/PIZZALOC/vn/

Phân tích

Trong bài toán này, ta sẽ phải xây K nhà hàng trong M vị trí. Ở đây, thực chất là ta sẽ phải liệt kê ra tổ hợp chập K của M phần tử trường hợp.

Với mỗi trường hợp, ta sẽ kiểm tra xem mỗi ngôi nhà có được phục vụ bởi nhà hàng nào hay không.

Mình sẽ triển khai bài toán sử dụng thuật toán quay lui có điều kiện - Backtracking.

Một điều chú ý là: với mỗi vị trí có thể đặt nhà hàng, mình sẽ kiểm tra xem tại vị trí đó, nếu như mình đặt nhà hàng thì nó sẽ phục vụ được cho những ngôi nhà nào. Kết quả mình sẽ lưu được vào một mảng. Điều này sẽ tránh bị time limit.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX_PLACE = 21;
const int MAX_HOUSE = 101;

int NumRest, R;                             // Số lượng nhà hàng và bán kính
int NumPlac;                                // Số địa điểm có thể đặt nhà hàng
int XPlace[MAX_PLACE], YPlace[MAX_PLACE];   // Toạ độ các điểm có thể đặt nhà hàng

int NumHous;                                // Số khu nhà
int XHouse[MAX_HOUSE], YHouse[MAX_HOUSE];   // Toạ độ các khu nhà

int NumPeop[MAX_HOUSE];                     // Số người ở mỗi khu nhà
int MaxPeop;                                // Số người tối đa có thể phục vụ
int SumPeop;                                // Tổng số người

// Lưu lại vị trí đã đặt của các nhà hàng
int PRest[MAX_PLACE];

// Kiểm tra xem một vị trí có thể phục vụ những ngôi nhà nào
int Reach[MAX_PLACE][MAX_HOUSE];

// Đếm số nhà mà nhà hàng có thể phục vụ ứng với mỗi vị trí
int Count[MAX_PLACE];

/*
* @PARAM: pos : lưu vị trí đang xét
* @PARAM: numIgnore : số vị trí ko đặt
* @PARAM: numRestor : số nhà hàng đã đặt
*/
void Check(int pos, int numIgnore, int numRestor)
{
	if(pos == NumPlac)
	{
		// Kiểm tra với những cách đã đặt cách nào phục vụ nhiều người nhất
		// Duyệt lần lượt các ngôi nhà, xem với mỗi ngôi nhà nó có được phục vụ không

		// Những người được phục vụ
		int SerPeop = 0;
		int Mark[MAX_HOUSE] = {0};

		for(int j = 0; j < NumRest; j++)
		{
			int idRest = PRest[j];

			for(int i = 0; i < Count[idRest]; i++)
			{
				// Chú ý: mỗi ngôi nhà chỉ được tính một lần.
				int idHouse = Reach[idRest][i];
				if(Mark[idHouse] == 0)
				{
					SerPeop += NumPeop[idHouse];
					Mark[idHouse] = 1;
				}

				// Nếu đã phục vụ được tối đa rồi thì thoát luôn
				if(SerPeop == SumPeop) break;
			}
		}

		if(SerPeop > MaxPeop) MaxPeop = SerPeop;

		return;
	}

	if(MaxPeop == SumPeop) return;

	// Đặt nhà hàng
	if(numRestor < NumRest)
	{
		PRest[numRestor] = pos;
		Check(pos + 1, numIgnore, numRestor + 1);
		if(MaxPeop == SumPeop) return;
	}

	// Ko đặt nhà hàng
	if(numIgnore < NumPlac - NumRest)
		Check(pos + 1, numIgnore + 1, numRestor);
}

int main()
{
	ios::sync_with_stdio(false);
	freopen("input.txt","r",stdin);

	cin >> NumRest >> R >> NumPlac;
	for(int i = 0; i < NumPlac; i++)
		cin >> XPlace[i] >> YPlace[i];

	SumPeop = MaxPeop = 0;

	cin >> NumHous;
	for(int i = 0; i < NumHous; i++)
	{
		cin >> XHouse[i] >> YHouse[i] >> NumPeop[i];
		SumPeop += NumPeop[i];
		Count[i] = 0;
	}

	// Lưu lại những ngôi nhà mà tại mỗi vị trí, nhà hàng có thể phục vụ
	for(int j = 0; j < NumPlac; j++)
		for(int i = 0; i < NumHous; i++)
		{
			int temp = (XHouse[i] - XPlace[j])*(XHouse[i] - XPlace[j]) +
				(YHouse[i] - YPlace[j])*(YHouse[i] - YPlace[j]);

			if(temp <= R*R) Reach[j][Count[j]++] = i;
		}

	// Đặt NumRest nhà hàng trong NumPlac vị trí
	Check(0, 0, 0);

	cout << MaxPeop << endl;

	return 0;
}

SPOJ.COM - Thuật toán bài COINS - Bytelandian gold coins

admin@phamvanlam.com — Sun, 16 Oct 2016 21:21:00 GMT

Đề bài:

Ở Byteland, họ có một hệ thống tiền tệ rất kì lạ.

Mỗi đồng tiền vàng của họ có một số nguyên viết trên đó. Một đồng xu n có thể được trao đổi tại ngân hàng thành 3 đồng xu n/2, n/3 và n/4. Nhưng những số này luôn được làm tròn xuống (vì ngân hàng cần phải có lãi).

Bạn có thể bán những đồng xu này thành tiền đô la Mỹ. Tỉ lệ trao đổi là 1:1. Tuy nhiên, bạn không thể mua những đồng xu này.

Bạn có một đồng vàng. Hỏi số tiền tối đa bạn có thể có được là bao nhiêu.

Đầu vào

Đầu vào sẽ bao gồm một vài test case (số test case <= 10). Mỗi testcase sẽ chỉ bao gồm 1 dòng là số n, 0 <= n <= 1000000000. Đó là số được ghi trên đồng xu.

Đầu ra

Với mỗi test case, in ra một dòng giá trị số tiền tối đa bạn có thể có được.

Ví dụ

Đầu vào:

12 
2

Đầu ra:

13 
2

Giải thích:

Test case 1: Bạn có thể đổi 12 thành 6, 4 và 3, rồi đổi chúng thành tiền tương ứng $6 + $4 + $3 = $13.
Test case 2: Nếu bạn thử đổi đồng xu 2 thành 3 đồng xu nhỏ hơn thì bạn sẽ nhận được 1, 0 và 0. Cuối cùng bạn chỉ nhận được $1. Do đó, trong trường hợp này, tốt nhất là bạn đổi đồng xu 2 thành $2.

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/COINS/

Phân tích

Bài toán này mình sẽ sử dụng đệ quy để quét hết tất cả các trường hợp có thể xảy ra. Với giới hạn thời gian là 9 giây thì cách này hoàn toàn có thể thực hiện được.

Nếu giới hạn thời gian nhỏ hơn thì với giá trị n tối đa là 1000000000, bắt buộc mình phải sử dụng thuật toán quy hoạch động - Dynamic programming để lưu lại trạng thái số tiền lớn nhất thu được sau khi trao đổi ứng với mỗi số n.

Ngoài ra, với giá trị n = 1000000000, thực tế là không thể khai báo mảng có độ dài như vậy. Do đó, mình sẽ chỉ lưu lại trạng thái tới giá trị n = 10000000.

Lời giải

Code C/C++

Cách 1:

Thời gian: 5.17s - Bộ nhớ 2.7M

#include <iostream>
using namespace std;

unsigned long int coins(unsigned long int n)
{
     unsigned long int a=n/2, b=n/3, c=n/4;

	 // Nếu đổi thành 3 đồng xu nhỏ hơn
	 // mà giá trị thu được lớn hơn thì đổi
     if (a+b+c>n)
		 return coins(a)+coins(b)+coins(c);

	 // Nếu không thì đổi luôn thành đồng xu.
     return n;
}

int main() {

	 //freopen("input.txt","r",stdin);
     unsigned long int n;

	 while(cin >> n)
     {
          cout << coins(n) << endl;
     }

	 return 0;
}

Cách 2:

Thời gian: 0.01s - bộ nhớ: 41M

#include <iostream>
using namespace std;

const int MAX = 10000000;
unsigned long int store[MAX];

unsigned long int coins(unsigned long int n)
{
    unsigned long int a=n/2, b=n/3, c=n/4;

	 // Nếu đổi thành 3 đồng xu nhỏ hơn
	 // mà giá trị thu được lớn hơn thì đổi
    if (a + b + c > n)
	{
		unsigned long int x,y,z;

		// Nếu giá trị đổi ra mà >= MAX hoặc < MAX
		// mà nó chưa được tính thì ta phải tính.
		// Ngược lại thì ta lấy luôn giá trị lưu trong mảng.
		if(a >= MAX || store[a] == 0)
		{
			x = coins(a);
			if(a < MAX) store[a] = x;
		}
		else x = store[a];

		if(b >= MAX || store[b] == 0)
		{
			y = coins(b);
			if(b < MAX) store[b] = y;
		}
		else y = store[b];

		if(c >= MAX || store[c] == 0)
		{
			z = coins(c);
			if(c < MAX) store[c] = z;
		}
		else z = store[c];

		return x + y + z;
	}

	// Nếu không thì đổi luôn thành đồng xu.
	return n;
}

int main()
{
	 //freopen("input.txt","r",stdin);
     unsigned long int n;

	 for(int i = 0; i < MAX; i++)
		 store[i] = 0;

     while(cin >> n)
     {
          cout << coins(n) << endl;
     }

     return 0;
}

SPOJ.COM - Thuật toán bài DIEHARD - Die Hard Game

admin@phamvanlam.com — Fri, 14 Oct 2016 21:49:00 GMT

Đề bài:

Trò chơi vô cùng đơn giản. Ban đầu bạn được cho 'H' lượng máu và 'A' lượng giáp. Tại mỗi thời điểm bất kỳ bạn có thể đứng ở 3 nơi - lửa, nước và không khí. Sau mỗi đơn vị thời gian, bạn phải di chuyển vị trí để có thể sống sót. Ví dụ, nếu bạn đang đứng ở lửa thì bạn có thể bạn có thể di chuyển sang nước hoặc không khí.

Nếu như bạn nhảy vào không khí, bạn sẽ được tăng 3 máu và tăng 2 giáp. Nếu bạn nhảy vào nước, bạn sẽ bị giảm 5 máu và 10 giáp. Nếu như bạn nhảy vào lửa, bạn sẽ bị giảm 20 máu và tăng 5 giáp. Nếu máu hoặc giáp của bạn <= 0 thì bạn sẽ chết ngay lập tức.

Hãy tìm thời gian tối đa bạn có thể sống.

Đầu vào

Dòng đầu tiên của đầu vào là số lượng testcase t. Mỗi testcase sẽ bao gồm 2 số H và A lần lượt là số máu và số giáp ban đầu.

Đầu ra

Vói mỗi testcase, in ra thời gian tối đa bạn có thể sống.

Chú ý: bạn có thể chọn 1 trong 3 vị trí cho di chuyển đầu tiên.

Ràng buộc:

1 <= t <= 10 
1 <= H, A <= 1000

Ví dụ

Đầu vào:

Đầu ra:

1 
1 
5

Bạn có thể tham khảo link gốc đề bài và submit code tại đây:http://www.spoj.com/problems/DIEHARD/

Phân tích

Theo đầu bài, ta có thể chọn 1 trong 3 vị trí cho lần di chuyển đầu tiên. Mà bạn có thể thấy rằng nếu nhảy vào không khí thì cả máu và giáp đều tăng. Do đó, mình chọn đứng ở không khí đầu tiên.

Vì chỉ có 3 vị trí nước, không khí và lửa nên khi bạn ở một vị trí bất kỳ thì có thể nhảy sang vị trí còn lại. Mà khi nhảy vào không khí, cả máu và giáp đều tăng. Do đó, nếu bạn nhảy theo thứ tự sau đây sẽ có lợi nhất: Không khí - nước - không khí hoặc Không khí - lửa - không khí.

Ở bài toán này, mình sẽ triển khai cách giải bằng đệ quy, sử dụng thuật toán quy hoạch động - Dynamic programming để lưu lại kết quả thời gian sống lớn nhất ứng với giá trị 'H' máu và 'A' giáp ban đầu.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

// Phải cho giá trị MAX lớn hơn ràng buộc đề bài
// Vì giá trị máu hoặc giáp có thể tăng lên
const int MAX		= 2005;
const int Fire		= 1;
const int Water		= 2;
const int Air		= 3;

int InitH, InitA;       // Giá trị máu và giáp ban đầu
int MaxTime[MAX][MAX];  // Mảng lưu giá trị thời gian sống lớn nhất
                        // ứng với giá trị 'H' máu và 'A' giáp

/*
* Tìm giá trị lớn nhất của 2 số
* @PARAM: a, b : là 2 số đầu vào
* RETURN: số lớn hơn trong 2 số
*/
int Max(int a, int b)
{
	if(a > b) return a;
	return b;
}

/*
* Tìm thời gian sống lớn nhất với giá trị máu và giáp ban đầu
* @PARAM: health, armor lần lượt là lượng máu và giáp ban đầu
* RETURN: giá trị thời gian sống lớn nhất
*/
int Check(int health, int armor)
{
	if(health <= 0 || armor <= 0) return -1;

	// Giả sử lúc đầu ta đang đứng ở Air, ta sẽ nhảy lần lượt sang Fire rồi về Air
    // Hoặc sang Water rồi về Air. Vì tại Air thì H và A đều tăng.
    // Nếu nhảy sang Fire rồi về Air: máu giảm : 3 - 20 = -17 và giáp tăng: 2 + 5 = 7
    // Nếu nhảy sang Water rồi về Air: máu giảm: 3 - 5 = -2 và giáp giảm: -10 + 2 = -8
	if(MaxTime[health][armor] == -1)
		MaxTime[health][armor] =
		    Max(Check(health - 17, armor + 7) + 2, Check(health - 2, armor - 8) + 2);

	return MaxTime[health][armor];
}

int main(int argc, char** argv)
{
	int T, test_case;

	ios::sync_with_stdio(false);
	//freopen("input.txt", "r", stdin);

	for(int i = 0; i < MAX; i++)
		for(int j = 0; j < MAX; j++)
			MaxTime[i][j] = -1;

	cin >> T;
	for(test_case = 0; test_case < T; test_case++)
	{
	    // Nhập đầu vào
		cin >> InitH >> InitA;

		// In kết quả
		cout << Check(InitH, InitA) << endl;
	}

	return 0;
}

SPOJ.COM - Thuật toán bài HOUSES - Những ngôi nhà

admin@phamvanlam.com — Thu, 13 Oct 2016 22:16:00 GMT

Đề bài:

Một công ty đầu tư xây dựng một khu nhà gồm L căn nhà nằm cạnh nhau trên một con đường. Có N người muốn mua nhà ở khu nhà này, biết rằng người thứ i muốn mua a_i căn nhà và mỗi người đều muốn mua những căn nhà nằm cạnh nhau. Do số căn nhà cần mua có thể nhỏ hơn tổng số căn nhà (L) nên sẽ có một số căn nhà chưa được bán. Để đảm bảo mỹ quan của khu nhà, công ty sẽ luôn luôn bán căn nhà đầu tiên (theo thứ tự từ trái sang phải).

Biết yêu cầu của những người mua, một cách bán những căn nhà của công ty có thể được biểu diễn bằng 1 dãy gồm L số. Trong đó số thứ i bằng 0 nếu căn nhà thứ i chưa được bán và bằng k nếu căn nhà thứ i được bán cho người thứ k.

Ví dụ: khi L=4, N=2, a₁ = 2, a₂=1, dãy "2 0 1 1" thể hiện một cách bán những căn nhà của công ty: căn nhà đầu tiên bán cho người thứ 2, căn nhà thứ 3 và thứ 4 bán cho người đầu tiên và căn nhà thứ 2 được để lại.

Yêu cầu: Hãy giúp công ty liệt kê các cách bán những căn nhà. Các cách bán căn nhà được liệt kê theo thứ tự từ điển của dãy số biểu diễn. Nếu số cách bán căn nhà lớn hơn 1000, chỉ cần liệt kê 1000 cách đầu tiên. (Biết rằng dãy a có thứ tự từ điển đứng trước dãy b nếu và chỉ nếu tồn tại chỉ số j, sao cho a_i = b_i với mọi i < j và a_j < b_j).

Đầu vào

Dòng đầu tiên: chứa 2 số nguyên L, N.
Dòng thứ 2 chứa N số nguyên, tương ứng là các giá trị a₁, a₂, …, a_n.

Giới hạn

1 ≤ L ≤ 100.
1 ≤ N ≤ 20.
a₁ + a₂ + ... + a_N ≤ L.

Đầu ra

Gồm nhiều dòng, mỗi dòng tương ứng với dãy số biểu diễn một cách bán những căn nhà của công ty, 2 số liên tiếp của dãy số được cách nhau bởi một khoảng trắng. Các dãy số được liệt kê theo thứ tự từ điển.

Ví dụ

Đầu vào:

4 2 
2 1

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://vn.spoj.com/problems/HOUSES/

Phân tích

Trong bài toán này mình sẽ sử dụng thuật toán quay lui có điều kiện - backtracking. Tư tưởng là lần lượt xét từng căn nhà. Tại mỗi căn nhà, mình sẽ xét 2 khả năng có thể là nó được bán hoặc không được bán.

Trong trường hợp căn nhà được bán, mình lại lần lượt xét các trường hợp là nó được bán cho người thứ 1, 2, 3,..., i,..N. Và bạn cần nhớ rằng, mỗi khi nhà được bán cho người thứ i thì đồng nghĩa với a_i căn nhà sẽ được bán cho người thứ i.

Trong trường hợp căn nhà không được bán, điều này chỉ xảy ra khi số căn nhà còn lại đủ cho những người còn lại. Vì bắt buộc phải bán nhà cho N người.

Sau đây là lời giải bài toán sử dụng thuật toán quay lui có điều kiện - backtracking.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 105;

int N;                  // Số người muốn mua nhà
int L;                  // Số lượng ngôi nhà
int a[MAX];             // Biểu diễn rằng : người thứ i sẽ mua a[i] ngôi nhà
int r[MAX];             // Mảng lưu kết quả
int SoldHouses;         // Tổng số ngôi nhà được mua
int FreeHouses;         // Tổng số ngôi nhà sẽ không được mua
int NumAnswer;          // Đếm số kết quả
bool Visit[MAX];        // Đánh dấu xem người thứ i đã mua hay chưa

/*
* idHouse: id ngôi nhà đang xét
* IgnoreHouses: tổng số những ngôi nhà đã bị bỏ qua, không bán
*/
void Check(int idHouse, int IgnoreHouses)
{
	// Nếu đã đủ 1000 kết quả thì return
	if(NumAnswer == 1000) return;

	// Nếu duyệt đến cuối cùng mà số nhà đã được bán hết thì ta được 1 kết quả
	if(idHouse >= L + 1)
	{
		NumAnswer++;
		for(int i = 1; i <= L; i++)
			cout << r[i] << " ";
		cout << endl;
		return;
	}

	// Không bán
	if(idHouse > 1 && IgnoreHouses < FreeHouses) Check(idHouse + 1, IgnoreHouses + 1);

	// Bán
	// Lần lượt bán cho người thứ i đến người thứ n
	for(int i = 1; i <= N; i++)
		if(!Visit[i])
		{
			Visit[i] = true;
			for(int j = 0; j < a[i]; j++)
				r[idHouse + j] = i;

			Check(idHouse + a[i], IgnoreHouses);

			for(int j = 0; j < a[i]; j++)
				r[idHouse + j] = 0;
			Visit[i] = false;
		}
}

int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);

	// Nhập đầu vào
	cin >> L >> N;

	SoldHouses = 0;
	for(int i = 1; i <= N; i++)
	{
		cin >> a[i];
		SoldHouses += a[i];
		Visit[i] = false;
	}

	FreeHouses = L - SoldHouses;
	NumAnswer = 0;

	// Xét các trường hợp
	Check(1, 0);

	return 0;
}

SPOJ.COM - Thuật toán bài NKGAURD - Bảo vệ nông trang

admin@phamvanlam.com — Wed, 12 Oct 2016 19:59:00 GMT

Đề bài:

Nông trang có rất nhiều ngọn đồi núi, để bảo vệ nông trang nông dân Thái muốn đặt người canh gác trên các ngọn đồi này.

Anh ta băn khoăn không biết sẽ cần bao nhiêu người canh gác nếu như anh ta muốn đặt 1 người canh gác trên đỉnh của mỗi đồi. Anh ta có bản đồ của nông trang là một ma trận gồm N (1 < N <= 700) hàng và M (1 < M <= 700) cột. Mỗi phần tử của ma trận là độ cao H_ij so với mặt nước biển (0 <= H_ij <= 10,000) của ô (i, j). Hãy giúp anh ta xác định số lượng đỉnh đồi trên bản đồ.

Đỉnh đồi là 1 hoặc nhiều ô nằm kề nhau của ma trận có cùng độ cao được bao quanh bởi cạnh của bản đồ hoặc bởi các ô có độ cao nhỏ hơn. Hai ô gọi là kề nhau nếu độ chênh lệch giữa tọa độ X không quá 1 và chênh lệch tọa độ Y không quá 1.

Đầu vào

Dòng 1: Hai số nguyên cách nhau bởi dấu cách: N và M
Dòng 2..N+1: Dòng i+1 mô tả hàng i của ma trận với M số nguyên cách nhau bởi dấu cách: H_ij

Đầu ra

Dòng 1: Một số nguyên duy nhất là số lượng đỉnh đồi.

Ví dụ

Đầu vào:

8 7 
4 3 2 2 1 0 1 
3 3 3 2 1 0 1 
2 2 2 2 1 0 0 
2 1 1 1 1 0 0 
1 1 0 0 0 1 0 
0 0 0 1 1 1 0 
0 1 2 2 1 1 0 
0 1 1 1 2 1 0

Đầu ra:

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://vn.spoj.com/problems/NKGUARD/

Phân tích

Theo đầu bài, đỉnh đồi là 1 hoặc nhiều ô nằm kề nhau của ma trận có cùng độ cao được bao quanh bởi cạnh của bản đồ hoặc bởi các ô có độ cao nhỏ hơn. Do đó, mình sẽ sử dụng thuật toán tìm kiếm theo chiều sâu DFS hoặc thuật toán tìm kiếm theo chiều rộng BFS. Cả 2 cách đều tương tự nhau (ở đây mình chỉ trình bày code theo thuật toán tìm kiếm theo chiều sâu DFS).

Tiếp theo, hai ô gọi là kề nhau nếu độ chênh lệch giữa tọa độ X không quá 1 và chênh lệch tọa độ Y không quá 1. Nghĩa là một ô sẽ có 8 ô xung quanh kề với nó.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX = 705;

int N,M;                // Lần lượt là số lượng hàng, cột của ma trận
int Answer;             // Kết quả là số lượng đỉnh đồi
int Map[MAX][MAX];      // Bản đồ của nông trang

bool Visit[MAX][MAX];   // Đánh dấu để kiểm tra đã duyệt hay chưa
bool IsHill;            // Đánh dấu xem có phải là đỉnh đồi hay không

int drow[8] = {-1,-1,-1, 0,0, 1,1,1};
int dcol[8] = {-1, 0, 1,-1,1,-1,0,1};

void DFS(int row, int col)
{
	// Tại mỗi điểm ta sẽ đánh dấu điểm đó đã được duyệt
	Visit[row][col] = true;

	for(int i = 0; i < 8; i++)
	{
		int r = row + drow[i];
		int c = col + dcol[i];

		if(r >= 0 && r < N && c >= 0 && c < M)
		{
			// Tại một điểm mà tồn tại 1 điểm kề có giá trị lớn hơn
			// thì điểm đó không phải đỉnh đồi
			if(IsHill && Map[r][c] > Map[row][col]) IsHill = false;

			// Duyệt tới các điểm có cùng độ cao mà chưa được duyệt
			// vì các điểm đó sẽ thuộc cùng 1 đỉnh đồi.
			if(Map[r][c] == Map[row][col] && !Visit[r][c]) DFS(r, c);
		}
	}
}

int main()
{
	//freopen("input.txt","r",stdin);
	ios::sync_with_stdio(false);

	// Nhập đầu vào
	cin >> N >> M;
	for(int i = 0; i < N; i++)
		for(int j = 0; j < M; j++)
		{
			cin >> Map[i][j];
			Visit[i][j] = false;
		}

	// Duyệt từng phần tử trong ma trận
	// và kiểm tra tại phần tử chưa được xét
	for(int i = 0; i < N; i++)
		for(int j = 0; j < M; j++)
			if(!Visit[i][j])
			{
				// Khởi tạo IsHill = true, sau đó sử dụng thuật toán DFS
				// để duyệt ma trận. Sau quá trình duyệt, nếu như IsHill vẫn có
				// giá trị true thì chứng tỏ điểm vừa xét là đỉnh đồi.
				IsHill = true;
				DFS(i, j);
				if(IsHill) Answer++;
			}

	// In kết quả số đỉnh đồi
	cout << Answer << endl;

	return 0;
}

SPOJ.COM - Thuật toán bài ABSYS - Anti-Blot System

admin@phamvanlam.com — Sun, 25 Sep 2016 21:25:00 GMT

Đề bài:

Tám là một học sinh lớp 2 rất thông minh, chăm chỉ và giỏi về lập trình. Gần đây, bạn ấy quyết định chuyển đổi toàn bộ nội dung ở vở ghi chép thành một phiên bản "điện tử". Tuy nhiên, Tám phát hiện ra rằng vở toán của bạn ấy bị dính đầy các vết mực.

Do đó, Tám đã scan lại toàn bộ nội dung và chuyển tới một thiết bị - cái mà bạn ấy đã lập trình ra nó từ khi mới biết chữ (quả là một thiên tài !!!). Thiết bị này thay thế tất cả vết mực thành dòng chữ "machula".

Vấn đề đặt ra ở đây là:

Bạn được đưa cho vở viết của Tám, được xử lý bởi thiết bị trên. Chúng bao gồm những bài toán đơn giản, được sử dụng để thực hành phép tính cộng với những số nguyên dương. Nhiệm vụ của bạn là phục hồi lại những vùng bị dính mực.

Đầu vào

Dòng đầu tiên là số tự nhiên T, xác định số lượng test case. Mỗi test case được bắt đầu bằng một dòng trống. Mỗi test case chỉ bao gồm 1 dòng, biểu diễn biểu thức dạng "number + number = number", trong đó, number là số nguyên dương. Một phần của biểu thức được thay thế bởi dòng chữ "machula". Dòng chữ này luôn luôn bao phủ một chuỗi các số không có dấu cách, thậm chí là bao phủ toàn bộ số. Giả sử mỗi biểu thức chỉ có một cách duy nhất để hoàn thành.

Đầu ra

Mỗi test case, đầu ra bao gồm 1 dòng dạng "number + number = number". Trong đó, tất cả các số đã được phục hồi.

Ví dụ

Đầu vào:

3 
23 + 47 = machula 
3247 + 5machula2 = 3749 
machula13 + 75425 = 77038

Đầu ra:

23 + 47 = 70 
3247 + 502 = 3749 
1613 + 75425 = 77038

Chú ý: với C++/C/Java sử dụng int, Pascal sử dụng longint là OK!

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/ABSYS/

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 1000;

bool IsDigit(char ch)
{
    if((ch >= '0' && ch <= '9')) return true;
    return false;
}

/*
* Trả về độ dài xâu nếu chúng chứa toàn chữ số từ 0 đến 9
* Nếu trong xâu có tồn tại kí tự không phải là số thì trả về -1
*/
int GetLength(char* arr)
{
    int length = 0;
    for(int i = 0; i < MAX; i++)
    {
        if(arr[i] == '') break;
        else if(IsDigit(arr[i])) length++;
        else
        {
            length = -1;
            break;
        }
    }
    return length;
}

/*
* Chuyển đổi xâu chứa toàn chữ số thành số nguyên kiểu int
* Nếu xâu đầu vào không hợp lệ, tức chứa kí tự không phải số
* thì trả về số -1
* ngược lại thì trả về giá trị của số tương ứng
*/
int ConvertArrayToInt(char* str)
{
    int length = GetLength(str);
    if(length < 0) return -1;

    int r = 0;
    for(int i = 0; i < length; i++)
        r = r * 10 + str[i] - '0';

    return r;
}

int main()
{
    ios::sync_with_stdio(false);

    // comment dòng này khi submit
    freopen("input.txt","r",stdin);

    int T = 0;
    cin >> T;

    // tạo ra mảng 5 phần tử để lưu 5 thành phần trong biểu thức
    int a[5];

    for(int tc = 0; tc < T; tc++)
    {
        for(int i = 0; i < 5; i++)
        {
            char str[MAX];
            cin >> str;

            a[i] = ConvertArrayToInt(str);
        }

        // Thực tế ta chỉ cần quan tâm đến phần tử a[0], a[2], a[4]
        // vì chúng là số
        int n1 = a[0];
        int n2 = a[2];
        int n3 = a[4];

        // Vì mỗi biểu thức chỉ có một cách duy nhất để hoàn thành,
        // nên chỉ có khả năng
        // là 1 trong 3 vị trí bị dính mực
        if(n1 < 0) a[0] = a[4] - a[2];
        else if (n2 < 0) a[2] = a[4] - a[0];
        else a[4] = a[0] + a[2];

        cout << a[0] << " + " << a[2] << " = " << a[4] << endl;
    }

    return 0;
}

SPOJ.COM - Thuật toán bài ADDREV - Adding Reversed Numbers

admin@phamvanlam.com — Sun, 25 Sep 2016 21:21:00 GMT

Đề bài:

Những diễn viên hài cổ của Malidinesia (ACM) thích thú với hài kịch hơn là bi kịch. Không may là hầu hết những tác phẩm kịch cổ đều là bi kịch. Vì vậy, người cố vấn kịch của ACM đã quyết định biến một vài vở bi kịch thành hài kịch. Tất nhiên, công việc này rất là khó bởi vì ý nghĩa cơ bản của vở kịch phải được giữ nguyên vẹn, mặc dù mọi thứ gần như thay đổi hoàn toàn. Ví dụ về số: nếu bất kì số nào xuất hiện ở bi kịch thì phải được đảo nghịch trước khi được chấp nhận thành hài kịch.

Số đảo nghịch là một số được viết bằng các chữ số Ả Rập nhưng các chữ số được viết theo thứ tự ngược lại. Số thứ nhất trở thành số cuối cùng và ngược lại. Ví dụ, nếu nhân vật chính có 1245 quả dâu tây ở vở bi kịch, thì bây giờ anh ấy có 5421 quả dâu tây. Chú ý rằng là không được phép có số nào mà chữ số '0' ở đầu. Có nghĩa là, nếu ta có một số 1200, thì số đảo nghịch của nó sẽ là 21. Cũng chú ý rằng là tất cả số đảo nghịch không có số 0 ở cuối.

ACM phải tính toán với các số đảo nghịch. Nhiệm vụ của bạn là phải xây dựng thuật toán để cộng 2 số đảo nghịch và in ra tổng của chúng được đảo nghịch. Dĩ nhiên, kết quả không phải duy nhất bởi vì 1 số có thể là đảo nghịch của nhiều số. Ví dụ số 21 có thể là đảo nghịch của 12, hoặc 120, hoặc 1200,… Vì vậy, chúng ta giả sử là không có số 0 nào bị mất đi trong quá trình đảo nghịch (do đó nếu số đảo nghịch là 21 thì suy ra số gốc phải là 12)

Đầu vào

Đầu vào bao gồm N trường hợp (N cỡ 10000). Dòng đầu tiên của đầu vào bao gồm 1 số nguyên dương duy nhất N. Sau đó, sẽ là các trường hợp. Mỗi trường hợp sẽ bao gồm một dòng với 2 số nguyên dương phân biệt bởi dấu cách. Chúng là các số đảo nghịch cần phải cộng.

Đầu ra

Với mỗi đầu ra, in ra chính xác 1 dòng với 1 số nguyên duy nhất - là số đảo nghịch của tổng 2 số. Chú ý là đầu ra không được phép có số 0 ở đầu.

Ví dụ

Đầu vào:

Đầu ra:

34 
1998 
1

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/ADDREV/

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int getRevere(int a)
{
    int leng = 0;
    int p[10];

    while(a)
    {
        int t = a % 10;
        p[leng++] = t;
        a = a/10;
    }

    int x = 0;
    for(int i = 0; i < leng; i++)
        x = x * 10 + p[i];

    return x;
}

int main()
{
    ios::sync_with_stdio(false);

    // comment trước khi submit
    freopen("input.txt","r",stdin);

    int T = 0;
    cin >> T;

    for(int i = 0; i < T; i++)
    {
        int x, y;
        cin >> x >> y;

        int a = getRevere(x) + getRevere(y);
        cout << getRevere(a) << endl;
    }

    return 0;
}

SPOJ.COM - Thuật toán bài AE1B - Tables

admin@phamvanlam.com — Sun, 25 Sep 2016 21:18:00 GMT

Đề bài:

Thuận làm việc như một thợ mộc. Anh đấy đã nhận một hợp đồng để làm s cái bàn bằng gỗ thông. Mặc dù, Thuận có rất nhiều gỗ, nhưng anh ta lại bị hết sạch đinh. Vì vậy, anh ấy cần đi đến cửa hàng và mang về một vài hộp đinh. Hỏi số lượng hộp đinh tối thiểu mà Thuận cần mang về để có đủ đinh cho những chiếc bàn?

Đầu vào

Dòng đầu tiên của đầu vào bao gồm 3 số nguyên n, k và s (1 <= n, k, s <= 1000) phân cách nhau bởi 1 dấu cách. Chúng biểu diễn cho số lượng hộp đinh ở của hàng của Thuận, số lượng đinh cần để làm ra 1 cái bàn và số lượng bàn cần phải làm. Dòng thứ hai bao gồm n (có thể giống nhau) số nguyên ai (1 <= ai <= 1000) phân cách nhau bởi 1 dấu cách, trong đó ai là số lượng đinh ở hộp đinh thứ i tại của hàng.

Đầu ra

Một dòng duy nhất chứa 1 số nguyên - là số lượng hộp đinh tối thiểu mà Thuận cần phải mang về từ cửa hàng để làm s cái bàn. Giả sử là Thuận có đủ số lượng đinh để làm tất cả bàn.

Ví dụ

Đầu vào:

5 6 3 
3 9 5 7 3

Đầu ra:

Giải thích:

Để làm 3 cái bàn, mỗi cái cần 6 đinh, tức là cần tổng là 18 cái đinh. Do đó, Thuận cần mang ít nhất là 3 cái hộp từ cửa hàng về nhà. Đáp án có thể là 3 hộp với số lượng đinh lần lượt làm (3, 7, 9) hoặc (9, 5, 7).

Tác giả: Jakub Lacki.

Bạn có thể tham khảo đề bài tiếng anh và submit tại đây: http://www.spoj.com/problems/AE1B/

Phân tích

Đối với bài toán này, bạn chỉ cần suy nghĩ một cách đơn giản. Đó là mình sẽ bắt đầu chọn từ hộp đinh có số lượng đinh nhiều nhất trước. Cho đến khi đủ số lượng đinh thì khi đó, số lượng hộp đinh cần chọn sẽ là ít nhất. Có hai cách để triển khai:

C1: Để có thể chọn được hộp đinh nhiều đinh nhất trước, thì ta có thể sử dụng 1 vòng lặp for để tìm ra phần tử lớn nhất mà chưa được chọn, sau đó đánh dấu nó là đã chọn. Sau khi chọn được hộp nhiều đinh nhất thì ta sẽ kiểm tra xem đã đủ lượng đinh chưa. Khi đủ rồi thì dừng lại.
C2: Hoặc cách thứ hai là chúng ta sẽ sắp xếp các hộp đinh theo thứ tự giảm dần số lượng đinh. Sau đó, chỉ cần dùng vòng lặp for để duyệt từ đầu mảng, thì đảm bảo chọn được hộp đinh nhiều nhất trước.

Lời giải

Code C/C++

Cách 1:

#include<iostream>
using namespace std;

const int MAX = 1000;

int  N;             // Lưu số lượng hộp đinh
int  K;             // Lưu số lượng đinh cần cho 1 cái bàn
int  S;             // Số lượng bàn cần làm
int  Screw[MAX];    // Lưu số lượng đinh của các hộp
bool Mark[MAX];     // Đánh dấu hộp đinh đã được chọn

int FindMax()
{
    int idmax = 0, max = 0;

    for(int i = 0; i < N; i++)
        if(Mark[i] == false && Screw[i] > max)
        {
            max   = Screw[i];
            idmax = i;
        }

    return idmax;
}

int main()
{
    ios::sync_with_stdio(false);

    // Comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    cin >> N >> K >> S;
    for(int i = 0; i < N; i++)
    {
        cin >> Screw[i];
        Mark[i] = false;
    }

    int sum = 0;    // số lượng đinh đã chọn
    int num = 0;    // số lượng hộp đinh đã chọn

    // Số lượng đinh cần thiết cho S cái bàn
    int need = K * S;

    while(sum < need)
    {
        int idmax = FindMax();
        Mark[idmax] = true;
        sum += Screw[idmax];
        num++;
    }

    cout << num << endl;

    return 0;
}

Cách 2:

#include<iostream>
using namespace std;

const int MAX = 1000;

int N;          // Lưu số lượng hộp đinh
int K;          // Lưu số lượng đinh cần cho 1 cái bàn
int S;          // Số lượng bàn cần làm
int Screw[MAX]; // Lưu số lượng đinh của các hộp

void Merge(int *a, int left, int m, int right)
{
    int l = left, r = m+1, k = 0;
    int *temp = new int[right - left + 1];

    while(l <= m && r <= right)
    {
        if(a[l] > a[r]) temp[k++] = a[l++];
        else temp[k++] = a[r++];
    }

    while(l <= m) temp[k++] = a[l++];

    while(r <= right) temp[k++] = a[r++];

    for(int i = 0; i < k; i++)
        a[i + left] = temp[i];

    delete[] temp;
}

void MergeSort(int *a, int left, int right)
{
    int m;
    if(left < right)
    {
        m = (left + right)/2;
        MergeSort(a, left, m);
        MergeSort(a, m + 1, right);
        Merge(a, left, m, right);
    }
}

int main()
{
    ios::sync_with_stdio(false);

    // Comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    cin >> N >> K >> S;
    for(int i = 0; i < N; i++)
        cin >> Screw[i];

    // Sắp xếp mảng của các hộp theo thứ tự số lượng đinh giảm dần
    // Mình dùng Merge Sort vì nó chạy nhanh, và mình cũng quen với việc triển khai nó
    // tuy nhiên bạn có thể dùng thuật toán sắp xếp khác.
    MergeSort(Screw, 0, N-1);

    int sum = 0;

    // Số lượng đinh cần thiết cho S cái bàn
    int need = K * S;

    // Chọn lần lượt từ các hộp đinh có số lượng đinh nhiều nhất trước
    // Cho đến khi nào đủ số lượng thì thôi
    int num;
    for(num = 0; num < N; num++)
    {
        if(sum >= need) break;
        else sum += Screw[num];
    }

    cout << num << endl;

    return 0;
}

SPOJ.COM - Thuật toán bài ALIEN - Aliens at the train

admin@phamvanlam.com — Sun, 25 Sep 2016 21:11:00 GMT

Đề bài:

Người ngoài hành tinh đã đi đến trái đất. Và tất cả mọi thứ đang rất hài hoà, hai loài này có thể sống được với nhau. Tuy nhiên, một người ngoài hành tinh giống cái thì không muốn nhìn thấy con người trên đường đi đến trường đại học.

Chú ý là người ngoài hành tinh phải sử dụng tàu giống như con người. Nhưng người ngoài hành tinh này có thể chọn bất kì một trạm để thoả mãn cô ta không nhìn thấy quá B người. Tuy nhiên, cô ta muốn đi xa nhất có thể trên tàu. Xin hãy giúp cô ta thực hiện nhiệm vụ này.

Đầu vào

Đầu tiên là số nguyên T biểu diễn số lượng test case, sau đó, dòng tiếp theo sẽ chứa 2 số nguyên At và Bt, lần lượt là số lượng trạm tàu (1 <= At <= 100000), và số lượng người tối đa mà người ngoài hành tinh muốn nhìn thấy(1 <= Bt <= 10000000). Sau đó, một dòng chứa At số nguyên phân biệt bởi dấu cách, biểu diễn số lượng người ở trạm thứ i.(Mỗi trạm sẽ không quá 100 người).

Đầu ra

Với mỗi test case, in ra một cặp gồm 2 số lần lượt là số lượng người mà người ngoài hành tinh sẽ gặp và số lượng trạm mà cô ta vượt qua.

Ví dụ

Đầu vào:

1 
5 100 
20 15 30 80 100

Đầu ra:

65 3

Giải thích:

Nếu người ngoài hành tinh này lên trạm số 1, sau đó là số 2, 3. Thì lúc này cô ta gặp 65 người. Nếu cô ta quyết định đi tiếp thì cô ta sẽ gặp 145 người. Do đó cô ta sẽ xuống tàu
Nếu cô ta chọn bắt đầu từ trạm số 2 với 15 người, sau đó đi tiếp lên trạm số 4 thì cô ta sẽ gặp 125 người.
Nhưng vì cô ta muốn gặp ít người nhất có thể và không vượt quá số người mong muốn. Nên cô ta quyết định chọn đi từ trạm 1 đến trạm 3.

Chú ý: Người ngoài hành tinh có thể chọn một trạm bất kì để xuất phát, và không thể đi lùi.

Bạn có thể tham khảo đề bài tiếng anh và submit tại đây: http://www.spoj.com/problems/ALIEN/

Phân tích

Bài toán này có đặc điểm là người ngoài hành tinh chỉ đi được theo một chiều và không thể quay ngược lại. Do đó, ta có thể sử dụng phương pháp "dịch cửa sổ" (sliding-window).

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX = 100005;

int At;            // Số lượng trạm tàu
int Bt;            // Số lượng người tối đa mà người ngoài hành tinh muốn nhìn
int a[MAX];        // Số lượng người tại mỗi trạm

int main()
{
    ios::sync_with_stdio(false);

    // comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    int T;
    cin >> T;

    for(int tc = 0; tc < T; tc++)
    {
        cin >> At >> Bt;
        for(int i = 0; i < At; i++)
            cin >> a[i];

        int max_path = 0;            // Đường đi dài nhất
        int min_sum  = Bt + 1;        // Số lượng người ít nhất đã gặp

        int i = 0, st = 0;
        int sum = 0;                // Số lượng người đã gặp

        while(i < At)
        {
            sum += a[i];

            // kiểm tra cho đến khi
            // tổng số người đã gặp > số lượng mong muốn
            if(sum > Bt)
            {
                // độ dài đường đi hiện tại
                int path = i - st;

                // số lượng người đã gặp hiện tại
                int people = sum - a[i];

                // Kiểm tra nếu đường đi dài hơn thì cập nhật
                // trường hợp đường đi bằng nhau thì chọn đường
                // có số lượng người gặp ít hơn
                if(path > max_path)
                {
                    max_path = path;
                    min_sum = people;
                }
                else if(path == max_path)
                {
                    if(people < min_sum) min_sum = people;
                }

                // tăng điểm bắt đầu cho đến khi
                //tổng số người < số lượng mong muốn để duyệt tiếp
                while(sum > Bt)
                {
                    sum -= a[st];
                    st++;
                }
            }

            i++;
        }

        // Kiểm tra lần cuối cùng
        int path = i - st;
        if(path > max_path)
        {
            max_path = path;
            min_sum  = sum;
        }
        else if(path == max_path)
        {
            if(sum < min_sum) min_sum = sum;
        }

        cout << min_sum << " "  << max_path << endl;

    }

    return 0;
}

SPOJ.COM - Thuật toán bài AMR10G - Christmas Play

admin@phamvanlam.com — Sun, 25 Sep 2016 21:00:00 GMT

Đề bài:

Lớp mẫu giáo của con mình đang chuẩn bị một vở kịch cho Noel (hy vọng rằng con trai mình sẽ giữ vai trò đội trưởng). Những đứa trẻ rất là hào hứng, tuy nhiên giáo viên của chúng thì lại rất vất vả. Cô ấy phải chuẩn bị phục trang cho K người lính. Cô ấy muốn mua tất cả trang phục với cùng 1 kích cỡ. Độ dài của chúng có thể thay đổi một lượng nhỏ sau này bởi cha mẹ của những đứa trẻ.

Vì vậy, cô ấy đã lấy chiều cao của tất cả những đứa trẻ. Bạn hãy giúp cô ấy chọn ra K đứa trẻ trong N đứa để đóng vai binh lính, sao cho chiều cao giữa đứa cao nhất và đứa thấp nhất là nhỏ nhất, nhờ đó mà sự thay đổi là ít nhất. Và nói với cô ấy sự chênh lệnh nhỏ nhất đó.

Đầu vào:

Dòng đầu tiên bao gồm số lượng test case T. Mỗi test case bao gồm 2 dòng. Dòng đầu tiên của mỗi test case bao gồm 2 số nguyên N và K. Dòng thứ hai bao gồm N số nguyên là chiều cao của N đứa trẻ.

Đầu ra:

Với mỗi test case, in ra kết quả tương ứng.

Ràng buộc:

T <= 30 
1 <= K <= N <= 20000 
1 <= chiều cao <= 1000000000

Ví dụ

Đầu vào:

Đầu ra:

0 
1 
3

Giải thích:

Test case số 1: giáo viên chỉ cần chọn 1 người làm binh lính, vì vậy, cô ấy có thể chọn bất kì ai làm binh lính. Do đó, độ chênh lệnh chiều cao cần tìm là 0
Test case số 2: giáo viên có thể chọn hai đứa trẻ có chiều cao là 4 và 5. Khi đó kết quả là 1
Test case số 3: giáo viên bắt buộc phải chọn hết, nên đáp án là 5 - 2 = 3

Bạn có thể tham khảo đề bài tiếng anh và submit tại đây: http://www.spoj.com/problems/AMR10G/

Phân tích:

Đầu tiên, nếu phải chọn 1 đứa trẻ thì kết quả là 0
Nếu phải trọn K > 1 đứa trẻ, ta sẽ sắp xếp dãy chiều cao của chúng theo thứ tự tăng dần, hoặc giảm dần Sau đó, ta chỉ cần kiểm tra độ chênh lệnh chiều cao giữa đứa trẻ thứ i và i + K - 1. Tìm ra trường hợp nào có độ chênh lệnh nhỏ nhất là kết quả cần tìm

Lời giải

Code C/C++:

#include<iostream>
using namespace std;

const int MAX = 20005;

int N;              // Lần lượt là số lượng đứa trẻ
int K;              // Số lượng trẻ cần đóng vai binh lính
int Height[MAX];    // Mảng lưu chiều cao của N đứa trẻ

void Merge(int *height, int left, int m, int right)
{
    int l = left, r = m + 1, k = 0;
    int *temp = new int[right - left + 1];

    while(l <= m && r <= right)
    {
        if(height[l] > height[r]) temp[k++] = height[l++];
        else temp[k++] = height[r++];
    }

    while(l <= m) temp[k++] = height[l++];

    while(r <= right) temp[k++] = height[r++];

    for(int i = 0; i < k; i++)
        height[i + left] = temp[i];

    delete[] temp;
}

void MergeSort(int *height, int left, int right)
{
    int m;
    if(left < right)
    {
        m = (left + right)/2;
        MergeSort(height, left, m);
        MergeSort(height, m + 1, right);
        Merge(height, left, m, right);
    }
}

int main()
{
    ios::sync_with_stdio(false);

    // comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    int TC = 0;
    cin >> TC;

    for(int tc = 0; tc < TC; tc++)
    {
        cin >> N >> K;
        for(int i = 0; i < N; i++)
            cin >> Height[i];

        // Nếu chỉ phải chọn 1 đứa trẻ thì đáp án là 0
        if(K == 1) cout << "0" << endl;
        else
        {
            // Sắp xếp những đứa trẻ theo chiều cao giảm dần
            MergeSort(Height, 0, N-1);

            // Khi mảng đã sắp xếp, ta chỉ cần kiểm tra độ chênh lệnh
            // chiều cao giữa đứa trẻ thứ i và thứ i + K - 1
            // chọn ra khoảng nào có độ chênh lệnh nhỏ nhất sẽ là kết quả cần tìm
            int min = 1000000005;
            for(int i = 0; i + K - 1 < N; i++)
            {
                int sub = Height[i] - Height[i+K-1];
                if(sub < min) min = sub;
            }
            cout << min << endl;
        }
    }

    return 0;
}

SPOJ.COM - Thuật toán bài ANARC09A - Seinfeld

admin@phamvanlam.com — Sun, 25 Sep 2016 20:55:00 GMT

Đề bài:

Mình đã viết những câu chuyện được nhiều năm rồi, một vài trong số đó thì khá là ngớ ngẩn, chỉ là biến những vấn đề đơn giản trở nên phức tạp, và những vấn đề phức tạp trở nên đơn giản. Nhưng, điều đó không dành cho vấn đề sau.

Bạn được đưa cho một chuỗi kí tự, không có dấu cách và được tạo bởi toàn những dấu ngoặc đóng và mở. Nhiệm vụ của bạn là tìm ra số bước tối thiểu để làm cho chuỗi kí tự này trở nên hợp lệ. Sự hợp lệ được định nghĩa như sau:

1. Chuỗi kí tự rỗng được gọi là hợp lệ

2. Nếu S hợp lệ thì, {S} cũng hợp lệ

3. Nếu S, T hợp lệ, thì kết hợp lại là ST cũng hợp lệ.

Tất cả những chuỗi sau là hợp lệ: {}, {}{} và {{}{}}. Nhưng những cái sau đây thì không hợp lệ: }{, {{}{, và {}{

Một bước được định nghĩa là một lần thay thế dấu mở ngoặc thành đóng ngoặc hoặc ngược lại.

Đầu vào

Gồm 1 hay nhiều test case. Mỗi test case được miêu tả trên 1 dòng. Dòng này không chứa dấu cách và chỉ chứa dấu mở ngoặc và đóng ngoặc. Có tối đa 2000 kí tự và tất cả đều có độ dài chẵn. Dòng cuối cùng của đầu vào được tạo bởi 1 hay nhiều dấu '-'.

Đầu ra

Mỗi test case, in ra theo mẫu:

k. N

Trong đó, k là số thứ tự test case (bắt đầu từ 1), và N là số bước tối thiểu để chuyển chuỗi đã cho thành chuỗi hợp lệ.

Ví dụ

Đầu vào:

}{ 
{}{}{} 
{{{} 
---

Đầu ra:

1. 2 
2. 0 
3. 1

Bạn có thể tham khảo đề bài tiếng anh và submit tại đây: http://www.spoj.com/problems/ANARC09A/

Phân tích

Ở đây ta sẽ sử dụng stack để loại bỏ những cặp hợp lệ. Bằng cách là lần lượt cho từng kí tự vào stack, nếu kí tự ở đỉnh stack là { mà kí tự cho thêm vào là } thì khi đó ta sẽ cho kí tự ở đỉnh stack ra ngoài. Vì chúng là cặp hợp lệ.

Sau đó, ta sẽ xử lí đối với những kí tự còn lại trong stack để tính ra số bước cần thiết.

Ở đây, mình không dùng thư viện có sẵn. Mình sử dụng mảng cùng với một biến để lưu độ dài mảng. Và sẽ thao tác với nó giống như stack.

Ví dụ: int stack[MAX], leng = 0;

Muốn push 1 phần tử x vào stack, mình sẽ xử lí như sau: stack[leng] = x; leng++;
Muốn pop phần tử ở stack ra thì mình sẽ xử lí như sau: leng--;

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 2005;

char str[MAX], stack[MAX];
int  stack_leng, Answer;

int GetLength(char *str)
{
    int length = 0;
    while(str[length] != '') length++;
    return length;
}

int main()
{
    ios::sync_with_stdio(false);

    // comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    int tc = 0;
    int length;

    while(true)
    {
        cin >> str;
        if(str[0] == '-') break;

        tc++;
        stack_leng = 0;
        length       = GetLength(str);
        Answer     = 0;

        // cho kí tự đầu tiên vào stack
        stack[stack_leng++] = str[0];

        for(int i = 1; i < length; i++)
        {
            // Nếu đỉnh stack là '{' và kí tự tiếp theo cho vào là '}'
            // thì bỏ cả hai ra khỏi stack vì cặp này đã hợp lệ
            // Các trường hợp khác thì sẽ cho tiếp vào stack
            if(stack[stack_leng-1] == '{' && str[i] == '}') stack_leng--;
            else stack[stack_leng++] = str[i];
        }

        //
        if(stack_leng == 0)
            Answer = 0;
        else if(stack[0] == '{')
            // thì bắt buộc stack phải có dạng: {{{{,
            // vì nếu có dấu } thì ta đã bỏ cặp đó ra khỏi stack rồi
            Answer = stack_leng / 2;
        else // stack[0] = '}'
        {
            // duyệt từ đầu của stack
            int start = 0;

            while(true)
            {
                if (start >= stack_leng) break;

                if(stack[start] == '}' && stack[start + 1] == '}')
                {
                    Answer ++;
                    start  +=2;
                }
                else if (stack[start] == '}' && stack[start + 1] == '{')
                {
                    Answer += 2;
                    start  += 2;
                }
                else if (stack[start] == '{')
                // thì chắc chắn các kí tự phía sau phải là {
                {
                    Answer += (stack_leng - start)/2;
                    break;
                }
            }
        }

        cout << tc << ". " << Answer << endl;
    }

    return 0;
}

SPOJ.COM - Thuật toán bài ARMY - Army Strength

admin@phamvanlam.com — Sun, 25 Sep 2016 20:49:00 GMT

Đề bài:

Đợt tấn công tiếp theo của MechaGodzilla đang trên đường đến trái đất. Và một lần nữa, trái đất sẽ phải chiến đấu với MechaGodzilla. Đội quân của MechaGodzilla bao gồm nhiều quái vật nguy hiểm, ví dụ như Space Godzilla, King Gidorah, và MechaGodzilla. Để ngăn chặn chúng, và bảo vệ trái đất, Godzilla và bạn cô ấy đang chuẩn bị cho trận chiến.

Vấn đề đặt ra:

Mỗi đội quân bao gồm nhiều loại quái vật khác nhau. Mỗi quái vật có sức mạnh được biểu diễn bởi một số nguyên dương. Số càng lớn thì quái vật càng mạnh. Cuộc chiến sẽ bao gồm nhiều trận nhỏ. Mỗi trận, tất cả những con quái vật yếu nhất sẽ bị giết.

Nếu có một vài quái vật yếu nhất, nhưng chúng ở cùng một đội thì một trong số chúng sẽ bị giết ngẫu nhiên. Nếu cả 2 đội quân đều có ít nhất một con quái yếu nhất thì con quái vật ở đội của MechaGodzilla sẽ bị giết. Cuộc chiến kết thúc khi tất cả quái vật một trong hai đội quân bị giết hết. Đội quân còn lại sẽ chiến thắng.

Bạn được cho sức mạnh của tất cả các con quái vật. Hãy tìm ra đội chiến thắng.

Đầu vào

Dòng đầu tiên là số nguyên T, chỉ số lượng test case. Mỗi test case bắt đầu bằng một dòng trắng. Mỗi test case sẽ bắt đầu bằng 1 dòng gồm 2 số dương NG, NM lần lượt là số lượng quái vật của đội Godzilla và MechaGodzilla. Hai dòng tiếp theo. Dòng thứ nhất bao gồm NG số nguyên dương biểu diễn sức mạnh của các con quái vật ở đội Godzilla. Dòng thứ 2 là NM số dương biểu diễn sức mạnh của các con quái vật ở đội MechaGodzilla.

Đầu ra

Với mỗi test case, in ra kết quả của cuộc chiến.

Nếu chắc chắn rằng đội Godzilla thắng thì in ra "Godzilla".

Nếu chắc chắn rằng đội MechaGodzilla thắng thì in ra "MechaGodzilla".

Ngược lại thì in ra "uncertain".

Ví dụ

Đầu vào:

Đầu ra:

Godzilla 
MechaGodzilla

Giải thích:

Test case 1: mỗi đội có 1 con quái vật, và chúng có cùng độ mạnh. Do đó, quái vật ở đội MechaGodzilla sẽ bị giết. Vì vậy, đội Godzilla sẽ thắng.
Test case 2: sẽ có 3 trận chiến, và trong mỗi trận quái vật của đội Godzilla sẽ chết. Cuối cùng, đội MechaGodzilla sẽ thắng.

Chú ý: với C/C++ sử dụng kiểu int và Pascal sử dụng kiểu longint là OK

Bạn có thể tham khảo đề bài tiếng anh và submit tại đây:http://www.spoj.com/problems/ARMY/

Phân tích:

Ta sẽ sắp xếp quái vật theo chiều độ mạnh tăng dần. Tạo 2 con trỏ để duyệt đồng thời 2 dãy. Sau đó kiểm tra xem con nào có độ mạnh yếu hơn thì sẽ bị diệt.

Sau quá trình duyệt, đội nào vẫn tồn tại quái vật thì sẽ thắng.

Thực tế, theo như yêu cầu đề bài thì chắc chắn sẽ có đội thắng.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int NG, NM;

void Merge(int *a, int left, int m, int right)
{
    int l = left, r = m + 1, k = 0;
    int *temp = new int[right - left + 1];

    while(l <= m && r <= right)
    {
        if(a[l] < a[r]) temp[k++] = a[l++];
        else temp[k++] = a[r++];
    }

    while(l <= m) temp[k++] = a[l++];

    while(r <= right) temp[k++] = a[r++];

    for(int i = 0; i < k; i++)
        a[left + i] = temp[i];

    delete[] temp;
}

void MergeSort(int *a, int left, int right)
{
    int m;
    if(left < right)
    {
        m = (left + right)/2;
        MergeSort(a, left, m);
        MergeSort(a, m + 1, right);
        Merge(a, left, m, right);
    }
}

int main()
{
    ios::sync_with_stdio(false);

    // comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    int Testcase = 0;
    cin >> Testcase;

    for(int tc = 0; tc < Testcase; tc++)
    {
        cin >> NG >> NM;

        int *ng_army = new int[NG];
        for(int i = 0; i < NG; i++)
            cin >> ng_army[i];

        int *nm_army = new int[NM];
        for(int i = 0; i < NM; i++)
            cin >> nm_army[i];

        // Sắp xếp sức mạnh của quái vật theo chiều độ mạnh tăng dần
        MergeSort(ng_army, 0, NG-1);
        MergeSort(nm_army, 0, NM-1);

        // 2 con trỏ vào 2 mảng, để duyệt lần lượt các phần tử
        int ig = 0, im = 0;
        while(ig < NG && im < NM)
        {
            // nếu độ mạnh quái vật ở đội MechaGodzilla <= độ mạnh
            // quái vật ở đội Godzilla thì quái vật đội MechaGodzilla sẽ chết
            // ngược lại thì quái vật đội Godzilla sẽ chết.
            // thực tế, sẽ luôn tồn tại 1 đội thắng
            if(nm_army[im] <= ng_army[ig]) im++;
            else if(nm_army[im] > ng_army[ig]) ig++;
        }

        // Đội nào vẫn còn quái vật thì sẽ thắng
        if(ig < NG) cout << "Godzilla" << endl;
        else cout << "MechaGodzilla" << endl;

        delete[] ng_army;
        delete[] nm_army;
    }

    return 0;
}

SPOJ.COM - Thuật toán bài MAXXOR - Find the max XOR value

admin@phamvanlam.com — Sun, 25 Sep 2016 20:44:00 GMT

Đề bài:

Bạn được đưa cho 2 số nguyên L và R. Và bạn phải tìm ra giá trị XOR lớn nhất của hai số a và b thỏa mãn L <= a <= R và L <= b <= R.

Đầu vào

Gồm 1 dòng chứa 2 số nguyên L và R thỏa mãn L, R <= 1e9

Đầu ra

In ra một số nguyên duy nhất là kết quả.

Ví dụ

Đầu vào:

1 10

Đầu ra:

Bạn có thể tham khảo đề bài tiếng anh và submit code tại đây: http://www.spoj.com/problems/MAXXOR/

Phân tích

Bài toán này nếu sử dụng thuật toán vét cạn - brute force thì rõ ràng với L, R tối đa là 10e9 thì chắc chắn sẽ bị time limit. Vì vậy mình sẽ sử dụng thuật toán tham lam - greedy để giải quyết bài toán.

Đối với phép tính XOR thì ta có kết quả như sau:

0 XOR 0 = 0 
0 XOR 1 = 1 
1 XOR 0 = 1 
1 XOR 1 = 0

Ở đây mình xét toán tử XOR là toán tử với bit. Do đó, mình chỉ quan tâm đến số biểu diễn dạng nhị phân.

Mình sẽ tìm ra vị trí bit mà tại vị trí đó một số có bit biểu diễn là 1 và 1 số có bit biểu diễn là 0. Thì chắc chắn mình sẽ tìm được 2 số a và b mà khi a XOR b sẽ cho kết quả lớn nhất.

Để dễ hiểu, mời bạn xem lại ví dụ trên. Với ví dụ trên đầu vào L = 1 và R = 10. Số L được biểu diễn dạng nhị phân là 0001 và số R được biểu diễn dạng nhị phân là 1010. Mình tìm được vị trí thứ 3 (đánh dấu vị trí từ 0) thỏa mãn. Khi đó mình tìm được 2 số a và b thỏa mãn sẽ là 0b1111 và 0b0000. Và kết quả XOR lớn nhất sẽ là 0b1111 tức là số 15 trong hệ thập phân.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int main()
{
    // Comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    // Nhập đầu vào
    int L,R;
    cin >> L >> R;

    // Một số nguyên thì tối đa là 32 bít
    // được đánh dấu từ vị trí 0 đến vị trí 31
    // Do đó khởi tạo pos = 31, tức là trỏ đến vị trí bit cao nhất
    int pos = 31;
    while(true)
    {
        // Kiểm tra tại vị trí đó
        // Và dịch dần cho đến khi tìm được vị trí thỏa mãn
        // 1 số được biểu diễn bởi bit 1 và số còn lại được
        // biểu diễn bởi bit 0
        bool check_right = R & (1 << pos);
        bool check_left  = L & (1 << pos);

        // Nếu tìm được thì break khỏi vòng lặp
        // Ngược lại, thì dịch
        if(check_right && !check_left) break;
        else pos--;
    }

    // Kết quả tìm được sẽ là số dạng nhị phân: 0b1111....111
    int result = 0;
    for(int i = 0; i <= pos; i++)
        result = result * 2 + 1;

    cout << result << endl;

    return 0;
}

SPOJ.COM - Thuật toán bài 1AE00 - Rectangles

admin@phamvanlam.com — Sun, 25 Sep 2016 20:36:00 GMT

Đề bài:

Thái có N hình vuông với kích thước 1. Hỏi có bao nhiêu dạng hình chữ nhật mà Thái có thể tạo ra từ những hình vuông này?

Biết rằng, 2 hình chữ nhật được xem là khác nhau nếu chúng không thể quay hay dịch chuyển để trở thành hình còn lại. Trong quá trình xây dựng lên hình chữ nhật, Thái không thể làm thay đổi hình dạng của các hình vuông và cũng không thể đặt chúng lên trên những hình còn lại.

Đầu vào

Gồm chỉ một dòng chứa một số nguyên N, với 1 <= N <= 10000.

Đầu ra

In ra chỉ một dòng chứa một số nguyên là những hình chữ nhật mà Thái có thể tạo ra.

Ví dụ

Đầu vào:

Đầu ra:

Giải thích:

Với N = 6 hình vuông, ta có thể tạo ra hình chữ nhật bằng cách lần lượt xét các hình chữ nhật với chiều cao bằng 1 hoặc 2. Như hình dưới đây.

Do đó, kết quả là 8 hình chữ nhật.

Tác giả: Jakub Radoszewski

Bạn có thể tham khảo đề bài tiếng anh và submit code tại: http://www.spoj.com/problems/AE00/

Phân tích

Đối với bài này, đầu vào N có giá trị tối đa là 10000. Do đó nếu sử dụng thuật toán vét cạn thì chắc chắn sẽ bị time limit. Ở đây mình sẽ dùng thuật toán tham lam - Greedy để giải quyết bài toán.

Ta sẽ lần lượt xét từng loại hình chữ nhật với chiều cao là 1, 2, 3,…Với mỗi lại ta sẽ suy ra được số hình chữ nhật với chiều cao như vậy. Trong ví dụ trên, N = 6 hình vuông:

Với hình chữ nhật chiều cao h = 1: Ta có chiều rộng tối đa tương ứng là: N / h = 6 / 1 = 6. Nghĩa là ta sẽ có thể tạo ra được 6 hình chữ nhật kích thước là: 1×1, 1×2, 1×3, 1×4, 1×5, 1×6 - Với hình chữ nhật có chiều cao h = 2: Chiều rộng tối đa là: 6 / 2 = 3. Nghĩa là ta có thể tạo ra 3 hình chữ nhật có kích thước là: 2×1, 2×2, 2×3. Tuy nhiên, bạn có thể thấy rằng hình chữ nhật 2×1 và 1×2 là một.

Do đó, để không bị trùng lặp, mình đưa vào thêm một điều kiện là hình chữ nhật tạo ra phải có chiều rộng không nhỏ hơn chiều cao. Tức là trong trường hợp này, mình chỉ lựa chọn 2 hình chữ nhật là 2×2 và 2×3

Như vậy, kết quả sẽ là 6 + 2 = 8 hình chữ nhật.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

int N;          // Số N đầu vào là số hình vuông cạnh 1
int Number;     // Lưu kết quả số hình chữ nhật có thể tạo ra

int main()
{
    // Comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    cin >> N;
    Number = 0;

    for(int height = 1; height <= N; height++)
    {
        // Với mỗi một chiều cao ta suy ra chiều rộng tối đa tương ứng
        // Từ đó tính được số hình chữ nhật với chiều cao như vậy
        int max_width = N / height;

        // Điều kiện để các hình chữ nhật không thể trùng lặp
        // Là chiều rộng phải lớn hơn chiều cao
        if(max_width > height - 1) Number += max_width - (height - 1);
        else break;
    }

    cout << Number << endl;

    return 0;
}

SPOJ.COM - Thuật toán bài ABA12C - Buying Apples

admin@phamvanlam.com — Sun, 25 Sep 2016 20:30:00 GMT

Đề bài:

Mạnh đã đến siêu thị để mua chính xác "k" Kg táo cho "n" người bạn của anh ta. Tuy nhiên siêu thị này rất kì lạ. Giá của các sản phẩm rất là khác nhau. Do đó, Mạnh đã đi đến khu vực bán táo để hỏi về giá của chúng. Người bán hàng đưa cho anh ta một cái bảng giá. Và Mạnh nhận thấy rằng giá của táo không được tính dựa trên 1 Kg. Táo được đóng gói trong bao bì, mỗi cái chứa 'x' Kg táo, x > 0 và 'x' là số nguyên. Một gói 'x' Kg táo có giá là 'y' VNĐ. Vì vậy có một tấm bảng được đặt trên bàn với số 'y' là giá của của một gói 'x' Kg táo. Nếu 'y' là -1 thì nó có nghĩa là gói đó sẽ không được bán. Với những thông tin như vậy, Mạnh quyết định mua tối đa 'n' gói cho 'n' người bạn của anh ấy. Nói cách khác là Mạnh không được phép mua nhiều hơn 'n' gói táo.

Mạnh rất quý bạn của anh ấy nên không muốn làm thất vọng họ. Bây giờ, anh ấy sẽ nói cho bạn biết về số lượng những người bạn. Và bạn phải nói cho anh ấy biết về số lượng tiền tối thiểu mà Mạnh phải bỏ ra.

Đầu vào

Dòng đầu tiên là số lượng test cases, C. Mỗi test case sẽ gồm 2 dòng. Dòng đầu tiên chứa số N và K, lần lượt là số lượng bạn của anh ấy và lượng táo (Kg) mà Mạnh muốn mua. Dòng thứ hai bao gồm K số nguyên phân biệt với nhau bởi dấu cách. Trong đó, số nguyên thứ i là giá của gói 'i' Kg. Và giá trị -1 có nghĩa là gói tương ứng sẽ không được bán. (i được tính từ 1)

Ràng buộc:

0 < N <= 100 
0 < K <= 100 
0 < Giá tiền <= 1000

Đầu ra

Đầu ra cho mỗi test case là một dòng chứa số lượng tiền mà Mạnh phải bỏ ra. In ra -1 nếu như Mạnh không thể làm hài lòng bạn anh ấy.

Ví dụ

Đầu vào:

2 
3 5 
-1 -1 4 5 -1 
5 5 
1 2 3 4 5

Đầu ra:

-1 
5

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/ABA12C/

Giải thích:

Có N = 3 người bạn, K = 5 Kg táo cần mua. Tiếp theo là giá của 5 gói (1, 2, 3, 4, 5) Kg. Tuy nhiên gói 1, 2 và 5 Kg không bán. Do đó chỉ còn gói 3 và 4 Kg. Nên Mạnh không thể mua chính xác 5 Kg táo. Vì vậy, anh ấy không thể làm hài lòng những người bạn.
Có N = 5 người bạn, K = 5 Kg táo cần mua. Giá của các gói 1, 2, 3, 4, 5 Kg tương ứng là 1, 2, 3, 4, 5. Mạnh có thể mua 5 gói 1 Kg. Vì vậy số tiền nhỏ nhất mà Mạnh cần bỏ ra là 5.

Phân tích

Đầu vào N, K có giá trị lớn nhất là 100. Nếu bạn giải quyết bài toán sử dụng phương pháp vét cạn. Thì ở đây, mỗi gói sẽ có hai khả năng là được chọn hoặc không.

=> Độ phức tạp của thuật toán trong trường hợp xấu nhất là 2^100 (thực tế độ phức tạp tính ra là 1000000000 thì thời gian chạy sẽ xấp xỉ 1 giây). Do đó, dùng vét cạn sẽ bị time limit.

Với những bài toán dạng này, ta sẽ sử dụng phương pháp quy hoạch động.

Với chú ý ở đây là: MinMoney[i] = Min{MinMoney[i], MinMoney[j] + Price[i - j]}

Trong đó:

MinMoney[i], MinMoney[j] là số tiền nhỏ nhất để mua đúng i , j kg
Price[i - j] là giá của gói 'i - j' kg.

Lời giải

Code C/ C++

#include <iostream>
using namespace std;

const int MAX = 105;

int N;                  // Số lượng bạn
int K;                  // Số lượng Kg táo cần mua
int Price[MAX];         // Lưu giá của các gói, Price[i] ứng với giá của gói thứ i
int MinMoney[MAX][MAX]; // MinMoney[i][j]: Số tiền nhỏ nhất cần bỏ ra để mua i Kg táo,
                        // và số gói không quá j
int main()
{
	ios::sync_with_stdio(false);
	//freopen("input.txt","r",stdin);

	int Testcase = 0;
	cin >> Testcase;
	for(int tc = 0; tc < Testcase; tc++)
	{
		cin >> N >> K;
		for(int i = 1; i <= K; i++)
		{
			cin >> Price[i];

			// Khởi tạo số tiền nhỏ nhất cần bỏ ra để mua chính xác i Kg táo,
			// chính là số tiền cần bỏ ra để mua 1 gói 'i' Kg táo.
			for(int j = 1; j <= N; j++)
				MinMoney[i][j] = Price[i];
		}

		// Cập nhật lại mảng MinMoney[] sử dụng quy hoạch động
		for(int i = 2; i <= K; i++)
			for(int x = 2; x <= N; x++)
				for(int j = 1; j < i; j++)
				{
					if(MinMoney[j][x - 1] < 0 || Price[i - j] < 0) continue;

					// Khi chưa có giá trị MinMoney[i], thì lượng tiền nhỏ nhất
					// chính là lượng tiền nhỏ nhất khi đã mua 'j' Kg
					// và mua thêm 'i-j' Kg
					int temp = MinMoney[j][x - 1] + Price[i - j];
					if(MinMoney[i][x] < 0 || temp < MinMoney[i][x])
						MinMoney[i][x] = temp;
				}
		cout << MinMoney[K][N] << endl;
	}
	return 0;
}

Code Python:

num_tc = int(raw_input())
for tc in xrange(0, num_tc):
    # Nhap dau vao
    N, K = map(int, raw_input().split())

    price = [0] * (K + 1)
    price[1:K+1] = map(int, raw_input().split())

    # Khoi tao so tien nho nhat de mua i kg tao
    # la so tien de mua 1 goi i Kg tao

    min_price = [([0] * (N + 1)) for row in xrange(K + 1)]

    for i in xrange(1, K + 1):
        for j in xrange(1, N + 1):
            min_price[i][j] = price[i]

    for i in xrange(2, K + 1):
        for x in xrange(2, N + 1):
            for j in xrange(1, i):
                if min_price[j][x - 1] < 0 or price[i - j] < 0 :
                    continue

                temp = min_price[j][x - 1] + price[i - j]

                if min_price[i][x] < 0 or temp < min_price[i][x]:
                    min_price[i][x] = temp

    print min_price[K][N]

SPOJ.COM - Thuật toán bài AFS - Amazing Factor Sequence

admin@phamvanlam.com — Sun, 25 Sep 2016 20:11:00 GMT

Đề bài:

Thái là bạn cùng lớp với Học - người rất giỏi về lập trình và đã tạo ra dãy số nguyên tố rất hay. Thái cảm thấy ghen tị với Học nên quyết định tạo nên dãy số cho riêng mình. Bởi vì anh ấy không quá sáng tạo, nên đã tạo ra một dãy với định nghĩa tương tự như của Học, chỉ khác ở f(n), cụ thể là:

a[0] = a[1] = 0;
Với n > 1, a[n] = a[n-1] + f(n), trong đó, f(n) là tổng các số nguyên dương ở tập S
Với S = {x | x < n và n % x = 0}

Bây giờ, Học đã yêu cầu Thái lập trình để tìm ra f(n) - như Thái đã định nghĩa. Do đó, Thái mong muốn sự giúp đỡ của bạn bởi vì anh ta không biết về lập trình. Nhiệm vụ của bạn đơn giản là tìm a[n] với số n cho trước (n < 10^6)

Đầu vào

Bạn được cho nhiều test case. Dòng đầu tiên bao gồm số T (T <= 100), tổng số test case. T dòng tiếp theo chứa một số nguyên dương duy nhất N với 1 < N < 10^6.

Đầu ra

Mỗi test case, in ra một dòng duy nhất là số a[n], được định nghĩa như trên.

Ví dụ

Đầu vào:

Đầu ra:

2 
5 
6

Giải thích:

f(2) = 1 {1} 
f(3) = 1 {1} 
f(4) = 3 {1, 2} 
f(5) = 1 {1}

Do đó:

a[2] = a[1] + f[2] = 0 + 1 = 1; 
a[3] = a[2] + f[3] = 1 + 1 = 2; 
a[4] = a[3] + f[4] = 2 + 3 = 5; 
a[5] = a[4] + f[5] = 5 + 1 = 6;

Bạn có thể tham khảo đề bài tiếng anh và submit tại đây: http://www.spoj.com/problems/AFS/

Phân tích

Ở đây ta có thể áp dụng đúng công thức để tính cho mỗi test case. Tuy nhiên, như vậy sẽ dẫn đến việc phải lập lại quá trình tính toán rất nhiều. Điều này sẽ dẫn đến time limit.

Khi đó thuật toán ta phải dùng là thuật toán quy hoạch động - Dynamic programming. Đối với những bài toán kiểu này, ta sẽ tính toán một lần và lưu kết quả đó vào một mảng. Như vậy, ta chỉ cần tính toán một lần. Và với mỗi test case chỉ in ra kết quả.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

typedef unsigned long long ull;

const ull MAX = 1000005;

ull a[MAX];            // Lưu mảng a
ull f[MAX];            // Lưu mảng f

void CreateArray()
{
    for(ull i = 0; i < MAX; i++)
        a[i] = f[i] = 0;

    // Tạo mảng f
    for(ull k = 1; k < MAX; k++)
    {
        // Cập nhật cho tất cả các số j có ước số là k
        for(ull j = k*2; j < MAX; j += k)
            f[j] += k;
    }

    // Tạo mảng a
    for(ull i = 2; i < MAX; i++)
        a[i] = a[i-1] + f[i];
}

int main()
{
    ios::sync_with_stdio(false);

    // comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    CreateArray();

    ull T;
    cin >> T;

    for(ull tc = 0; tc < T; tc++)
    {
        ull n;
        cin >> n;
        cout << a[n] << endl;
    }

    return 0;
}

SPOJ.COM - Thuật toán bài AGGRCOW - Aggressive cows

admin@phamvanlam.com — Sun, 25 Sep 2016 20:11:00 GMT

Đề bài:

Trung đã xây dựng một cái chuồng mới rất dài, với N (2 <= N <= 100000) ngăn. Các ngăn được xếp theo một đường thẳng tại vị trí x1, x2,…, xN (0 <= xi <= 1000000000). Trung nuôi C con bò (2 <= C <= N). Và chúng không thích cách bố trí của cái chuồng này. Do đó, chúng luôn gây sự với những con bò mới khi nó được đặt vào một ngăn nào đó. Để ngăn cho những con bò này đánh nhau, Trung muốn đưa các con bò vào chuồng sao cho, khoảng cách ngắn nhất giữa hai con bất kì là lớn nhất có thể. Hỏi khoảng cách này là bao nhiêu?

Đầu vào

t - số lượng test cases, sau đó là t test cases theo sau.

Dòng 1: Bao gồm 2 số nguyên ngăn cách bởi dấu cách: N và C

Dòng 2…N+1: Dòng i + 1 chứa số nguyên xi là vị trí của chuồng thứ i.

Đầu ra

Với mỗi test case, in ra một số nguyên - là khoảng cách cần tìm.

Ví dụ

Đầu vào:

Đầu ra:

Giải thích: Trung có thể đặt 3 con bò vào các vị trí 1, 4 và 8. Do đó kết quả là 3

Bạn có thể tham khảo đề bài tiếng anh và submit tại đây: http://www.spoj.com/problems/AGGRCOW/

Phân tích

Với bài toán này, ta sẽ sắp xếp lại mảng vị trí các ngăn sao cho toạ độ tăng dần. Sau đó dùng thuật toán chia để trị - Divide and Conquer, để tìm ra kết quả.

Chú ý: khoảng cách ngắn nhất giữa hai ngăn tối thiểu là 1, và tối đa là khoảng cách giữa ngăn đầu và ngăn cuối.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 100005;

int Answer;             // Lưu kết quả
int N;                  // Lưu số lượng ngăn trong chuồng
int C;                  // Lưu số lượng con bò
int X[MAX];             // Lưu toạ độ các ngăn
int Left, Right;

void Merge(int *a, int left, int m, int right)
{
    int *temp = new int[right-left+1];
    int k = 0, i = left, j = m + 1;

    while(i <= m && j <= right)
    {
        if(a[i] < a[j]) temp[k++] = a[i++];
        else temp[k++] = a[j++];
    }

    while(i <= m) temp[k++] = a[i++];

    while(j <= right) temp[k++] = a[j++];

    for(int i = 0; i < k; i++)
        a[i + left] = temp[i];

    delete[] temp;
}

void MergeSort(int *a, int left, int right)
{
    int m;
    if(left < right)
    {
        m = (left + right) / 2;
        MergeSort(a, left, m);
        MergeSort(a, m + 1, left);
        Merge(a, left, m, right);
    }
}

bool IsValid()
{
    // Ta sẽ xếp thử các con bò vào các ngăn, bắt đầu từ ngăn đầu tiên
    int pos = 0, cnt = 1, delta = 0, i = 1;

    while(i < N)
    {
        // Khoảng cách giữa ngăn thứ 'i' và ngăn 'pos'
        delta = X[i] - X[pos];

        // Vì Answer ở đây là khoảng cách ngắn nhất giữa các chuồng
        // Nên buộc delta phải lớn hơn Answer thì ta mới xếp được
        if(delta >= Answer)
        {
            pos = i;
            cnt++;
        }

        i++;

        // Nếu xếp được hết C con bò thì thoả mãn,
        // ngược lại là không thể xếp C con bò vào N ngăn mà khoảng cách ngắn nhất
        // giữa hai chuồng là Answer
        if(cnt == C) return true;
    }

    return false;
}

int main()
{
    ios::sync_with_stdio(false);

    // Comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    int T;
    cin >> T;

    for(int tc = 0; tc < T; tc++)
    {
        // Input
        Answer = 0;

        cin >> N >> C;
        for(int i = 0; i < N; i++)
            cin >> X[i];

        // Implementing code below
        MergeSort(X, 0, N-1);

        // Binary search
        Left  = 1;
        Right = X[N-1] - X[0];

        while (Left < Right - 1)
        {
            // Answer chính là khoảng cách ngắn nhất đang xét
            // giữa các ngăn
            Answer = (Left + Right) / 2;

            if (IsValid()) Left = Answer;
            else Right = Answer - 1;
        }

        // Kiểm tra xem là tại Left hoặc Right thoả mãn thì lấy
        Answer = Right;
        if(!IsValid()) Answer = Left;

        // ouput
        cout << Answer << endl;
    }

    return 0;
}

SPOJ.COM - Thuật toán bài BOOKS1 - Copying Books

admin@phamvanlam.com — Sun, 25 Sep 2016 19:59:00 GMT

Đề bài:

Trước khi máy photo sách được phát minh ra, việc tạo ra một bản photo cho một quyển sách là vô cùng khó khăn. Tất cả nội dung phải được ghi chép lại bằng tay. Một người thợ được đưa cho quyển sách và anh ta phải hoàn thành nó sau một vài tháng. Một trong những người thợ nổi tiếng sống ở thế kỉ 15, và tên anh ta là Tèo. Nhưng dù sao thì công việc cũng vô cùng chán và buồn tẻ. Và chỉ có một cách để cải thiện tình hình đó là thuê những người thợ khác.

Hồi đó, có một đoàn múa hát muốn trình diễn một vở kịch rất nổi tiếng. Kịch bản được chia ra làm nhiều cuốn. Và diễn viên cần có nhiều bản copy của chúng. Tưởng tượng rằng bạn có m cuốn sách (đánh số từ 1, 2,…, m) có số trang lần lượt là p[1], p[2], …, p[m]. Và bạn phải tạo ra bản copy của mỗi cuốn đó. Nhiệm vụ của bạn là chia m cuốn sách đó cho k người thợ, k <= m. Mỗi cuốn chỉ phép giao cho một người thợ duy nhất. Và mỗi người thợ phải nhận những cuốn sách liên tiếp nhau. Có nghĩa là tồn tại một dãy số tăng dần thoả mãn 0 = b[0] < b[1] < b[2] < … < b[k] = m sao cho người thợ thứ i lấy những cuốn sách được đánh số giữa b[i-1] + 1 và b[i]. Thời gian để tạo ra bản copy của tất cả những cuốn sách được xác định dựa trên người thợ nhận nhiều việc nhất. Vì vậy, nhiệm vụ đặt ra là tối thiểu hoá số lượng trang sách lớn nhất được giao cho mỗi người thợ. Hãy tìm ra giải pháp cho vấn đề này.

Đầu vào

Đầu vào gồm N trường hợp (N <= 200). Bắt đầu là số nguyên dương N, là số lượng trường hợp. Sau đó là các trường hợp. Mỗi cái gồm chính xác 2 dòng. Dòng đầu tiên gồm 2 số nguyên m và k, 1 <= k <= m <= 500. Dòng thứ hai bao gồm các số p1, p2,…, pm phân cách nhau bởi dấu cách. Tất cả giá trị này đều là số dương và nhỏ hơn 10000000.

Đầu ra

Với mỗi trường hợp, in ra trên một dòng , bao gồm dãy p1, p2,…, pm được chia làm k phần. Sao cho tổng lớn nhất của mỗi phần là nhỏ nhất. Và ưu tiên cho những người thợ đầu tiên trước - nghĩa là người thợ đầu tiên làm ít hơn người thợ thứ 2, … Sử dụng dấu '/' để phân cách các phần. Có 1 dấu cách duy nhất giữa 2 số liên tiếp; giữa số và '/'.

Ví dụ

Đầu vào:

2 
9 3
100 200 300 400 500 600 700 800 900 
5 4 
100 100 100 100 100

Đầu ra:

100 200 300 400 500 / 600 700 / 800 900 
100 / 100 / 100 / 100 100

Giải thích:

Trường hợp thứ nhất, tổng lớn nhất của mỗi phần là 1700
Trường hợp thứ hai, tổng lớn nhất mỗi phần là 200

Bạn có thể tham khảo đề bài tiếng anh và submit code tại: http://www.spoj.com/problems/BOOKS1/

Phân tích

Với bài toán số lượng đầu vào khá lớn như này, ta sẽ không thể sử dụng thuật toán vét cạn - Brute force

Ở đây ta sẽ dùng thuật toán chia để trị - Divide and Conquer.

Lời giải

(Bạn nên tự mình nghĩ ra thuật của bài toán trước khi tham khảo code của mình nhé. Hãy phát huy tối đa khả năng sáng tạo của bản thân. Hơn nữa code mình viết ra cũng chưa thật sự tối ưu. Nên rất mong nhận được sự chia sẻ của bạn.)

Code C/C++

#include<iostream>
using namespace std;

typedef long long int ll;

const int MAX = 505;

ll M, K;                // Lưu số lượng cuốn sách, và số phần cần chia
ll Left,Right, mid;
ll Page[MAX];           // Lưu số lượng trang sách của mỗi cuốn
ll Index[MAX];          // Mảng lưu chỉ số của phần tử đầu tiên của mỗi phần
ll ValidIndex[MAX];     // Kết quả cuối cùng

// Cập nhật lại từng phần sao cho tổng mỗi phần không lớn hơn mid
void Update(ll id)
{
    ll sum = 0, t = Index[id];

    for(ll i = Index[id + 1] - 1; i >= t; i--)
    {
        sum += Page[i];

        if(sum == mid)
        {
            Index[id] = i;
            break;
        }else if(sum > mid)
        {
            Index[id] = i + 1;
            break;
        }
    }
}

// Kiểm tra xem với với số lượng lớn nhất của các phần là mid
// có hợp lệ hay không
bool IsValid()
{
    for(int i = 0; i < K; i++)
        Index[i] = i;
    Index[K] = M;

    // Cập nhật lại từng phần
    for(int i = K - 1; i >= 0; i--)
        Update(i);

    // Nếu sau
    if (Index[0] > 0) return false;

    return true;
}

int main()
{
    ios_base::sync_with_stdio(false);

    // comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    int T;
    cin >> T;

    for(int tc = 0; tc < T; tc++)
    {
        ll max_page = 0;        // Tìm ra cuốn sách có nhiều trang nhất
        ll sum_page = 0;        // Tìm tổng số trang

        cin >> M >> K;

        for(int i = 0; i < M; i++)
        {
            cin >> Page[i];

            if(Page[i] > max_page) max_page = Page[i];
            sum_page += Page[i];
        }

        // Khi chia ra thành các phần, thì tổng lớn nhất của các phần
        // sẽ nằm trong khoảng từ Left = max_page (số trang nhiều nhất)
        // và Right = sum_page (số trang nhiều nhất)
        Left  = max_page;
        Right = sum_page;

        // Triển khai thuật toán chia để trị
        while (Left < Right)
        {
            mid = (Left + Right) / 2;

            if (IsValid())
            {
                Right = mid;

                // Ta dùng mảng để lưu lại chỉ số của các phần tử
                // để phân chia các phần.
                for(int i = 0; i < K; i++)
                    ValidIndex[i] = Index[i];
            }
            else
            {
                Left = mid + 1;
            }
        }

        // In ra kết quả
        for(int i = 0; i < K - 1; i++)
        {
            for(int j = ValidIndex[i]; j < ValidIndex[i+1]; j++)
                cout << Page[j] << " ";
            cout << "/ ";
        }

        for(int i = ValidIndex[K-1]; i < M; i++)
        {
            cout << Page[i];
            if(i == M-1) break;
            cout << " ";
        }

        cout << endl;
    }

    return 0;
}

SPOJ.COM - Thuật toán bài EASUDOKU - Easy sudoku

admin@phamvanlam.com — Sun, 25 Sep 2016 06:58:00 GMT

Đề bài:

Bạn được yêu cầu tìm thuật toán để giải quyết bài toán sudoku cơ bản.

Đầu vào

Dòng đầu vào bao gồm số lượng test case t, 1 <= t <= 15. Mỗi test case bao gồm 81 số từ 0 đến 9 được phân cách nhau bởi dấu cách, và 9 số trên 1 dòng. Số 0 nghĩa là số cần phải điền.

Đầu ra

Nếu không tồn tại giải pháp để giải quyết bài toán thì in ra "No solution". Ngược lại thì bạn phải in 81 số đó ra, và phân cách nhau giống như đầu vào.

Bạn có thể tham khảo đề bài tiếng anh và submit code tại: http://www.spoj.com/problems/EASUDOKU/

Phân tích

Trước khi giải bài toán này, bạn chắc đã biết về sudoku. Còn nếu bạn chưa biết về sudoku thì sau đây mình sẽ giới thiệu qua về luật chơi, như sau:

Có nhiều loại sudoku, ở đây là bài toán sudoku cơ bản. Kích thước là 9×9. Và được chia ra làm 9 khối nhỏ hơn có kích thước 3×3. Sudoku được giải khi tất cả các số trên ma trận đã được điền hết.

Thoả mãn yêu cầu: Trên mỗi hàng, mỗi cột, và mỗi khối 3×3 nhỏ phải được điền các số từ 1 đến 9, mỗi số xuất hiện đúng 1 lần, tức là không số nào được lặp lại từ 2 lần trở lên;

Qua đó, thuật toán có thể sử dụng ở đây đó là thuật toán quay lui có điều kiện - backtracking. Nghĩa là, tại mỗi ô cần giải, ta sẽ điền thử từ 1 đến 9. Nếu ta có thể điền hết thì đó chính là giải pháp. Ngược lại thì sẽ không có giải pháp cho bài toán.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

// Lưu ma trận suduku
int Matrix[9][9];

// Kết quả bài toán, Answer = true => có giải pháp, Answer = false nghĩa là không có
bool Answer;

// Lưu trạng thái tại từng hàng, cột từ 0 đến 9, các số từ 1 đến 9 đã có chưa
bool Row[9][10], Col[9][10];

void Next(int &row, int &col)
{
    if(col < 8) col++;
    else
    {
        col = 0;
        row++;
    }
}

bool IsValid(int row, int col, int value)
{
    // Kiểm tra xem tại cột đang xét, giá trị 'value' này đã có chưa
    if(Col[col][value] == true) return false;

    // Kiểm tra xem tại hàng đang xét, giá trị 'value' này đã có chưa
    if(Row[row][value] == true) return false;

    // Kiểm tra xem trong khối nhỏ 3x3 đã có giá trị 'value' hay chưa
    int sr = row - row % 3;
    int sc = col - col % 3;

    for(int i = 0; i < 3; i++)
        for(int j = 0; j < 3; j++)
            if(Matrix[i + sr][j + sc] == value) return false;

    return true;
}

void Check(int row, int col)
{
    // Nếu đi được hết các dòng thì có nghĩa là đã có giải pháp
    if(row == 9)
    {
        Answer = true;
        return;
    }

    // Nếu tại ô đó đã có giá trị khác 0 thì ta sẽ kiểm tra đến ô tiếp theo
    if (Matrix[row][col] != 0)
    {
        Next(row, col);
        Check(row, col);
    }
    else // Nếu ô đó = 0 thì bắt đầu điền thử giá trị từ 1 đến 9
    {
        int old_row, old_col;

        for(int i = 1; i <= 9; i++)
        {
            // Kiểm tra xem nếu ô tại hàng row, và cột col,
            // điền giá trị i có hợp lệ không. Nếu hợp lệ thì điền thử
            if(IsValid(row, col, i))
            {
                old_row = row;
                old_col = col;

                Matrix[row][col] = i;
                Row[row][i] = true;
                Col[col][i] = true;
                Next(row,col);

                Check(row,col);

                if(Answer) return;

                row = old_row;
                col = old_col;
                Row[row][i] = false;
                Col[col][i] = false;
                Matrix[row][col] = 0;
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);

    // Comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    int T;
    cin >> T;

    for(int tc = 0; tc < T; tc++)
    {
        Answer = false;
        for(int i = 0; i < 9; i++)
            for(int j = 1; j <= 9; j++)
                Row[i][j] = Col[i][j] = 0;

        // Nhập vào ma trận
        // đồng thời kiểm lưu trạng thái các số đã có hay chưa tại từng hàng, cột
        for(int i = 0; i < 9; i++)
            for(int j = 0; j < 9; j++)
            {
                int tmp;
                cin >> tmp;
                Matrix[i][j] = tmp;

                // Tại dòng i, số có giá trị tmp đã xuất hiện
                Row[i][tmp] = true;
                // Tại cột j, số có giá tị tmp đã xuất hiện
                Col[j][tmp] = true;
            }

        // Bắt đầu xét từ ô đầu tiên hàng = 0 và cột = 0
        Check(0, 0);

        // In kết quả
        if(Answer)
        {
            for(int i = 0; i < 9; i++)
            {
                for(int j = 0; j < 9; j++)
                    cout << Matrix[i][j] << " ";
                cout << endl;
            }
        }
        else cout << "No solution" << endl;

    }

    return 0;
}

SPOJ.COM - Thuật toán bài BOKAM143SOU - Checking cubes

admin@phamvanlam.com — Sun, 25 Sep 2016 06:42:00 GMT

Đề bài:

Cho một số nguyên N. Tìm ra số lượng cách để biểu diễn số N thành tổng của tối đa 5 số lập phương.

Đầu vào

1 dòng chứa số N, với 1 <= N <= 12500.

Đầu ra

In ra kết quả về số lượng cách.

Ví dụ:

Đầu vào:

Đầu ra:

Giải thích:

Cách 1: 64 = 27 + 27 + 8 + 1 + 1
Cách 2: 64 = 64 + 0 + 0 + 0 + 0

Bạn có thể tham khảo đề bài tiếng anh và submit code tại: http://www.spoj.com/problems/BOKAM143SOU/

Phân tích

Trước tiên ta sẽ tìm tất cả những số lập phương không lớn hơn N.

Sau đó kiểm tra tất cả các trường hợp có thể. Có nhiều cách triển khai, tuy nhiên ở đây mình triển khai theo thuật toán quay lui có điều kiện - Backtracking.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

int N;          // Số đầu vào
int Answer;     // Số lượng cách
int A[51];      // Mảng lưu các số lập phương <= N
int Leng;       // Lưu số lượng các số lập phương <= N

/*
* num : số phần tử đã chọn, khi num = 5 thì sẽ được một cách
* sum : là tổng của các số đã chọn
* oldpos : lưu vị trí của số đã chọn lúc trước
* số chọn sau phải có vị trí lớn hơn hoặc bằng vị trí số chọn trước
* => các cách sẽ không bị lặp lại
*/
void Check(int num, int sum, int oldpos)
{
    // Khi chọn đủ 5 số mà tổng các số đã chọn == N thì được 1 cách mới
    if(num == 5)
    {
        if(sum == N) Answer++;
        return;
    }

    // Duyệt mảng các số lập phương <= N để thử các số
    for(int i = 0; i < Leng; i++)
        if(i >= oldpos)
            Check(num + 1, sum + A[i], i);
}

int main()
{
    // Comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    cin >> N;
    Leng   = 0;
    Answer = 0;

    // Tìm ra tất cả các số lập phương <= N và lưu vào 1 mảng
    while(true)
    {
        int temp = (Leng * Leng * Leng);
        if(temp > N) break;
        A[Leng++] = temp;
    }

    // Bắt đầu backtrack để thử tất cả các trường hợp xảy ra
    Check(0, 0, -1);

    cout << Answer << endl;

    return 0;
}

SPOJ.COM - Thuật toán bài BENEFACT - The Benefactor

admin@phamvanlam.com — Sun, 25 Sep 2016 06:33:00 GMT

Đề bài:

Ngày xửa ngày xưa, tại một thành phố, người dân quyết định lựa chọn ra một vị thị trưởng. Tại thời điểm đó, có một ý tưởng rất mới và chiến dịch bầu cử hoàn toàn chưa biết. Nhưng dĩ nhiên một vài người dân muốn trở thành thị trưởng. Và nó không mất thời gian để nhận ra rằng việc đưa ra những lời hứa tốt sẽ không trở nên có hiệu quả. Một ứng cử viên được chọn nếu như những món quà giá trị của ông ta đem lại lợi ích cho những người dân trong thành phố.

Một ngày trước ngày bầu cử, một ứng cử viên đã hứa với người dân trong thành phố. Nếu như chiến thắng trong cuộc bầu cử thì anh ta sẽ đảm bảo rằng: tại một trong những con đường của thành phố sẽ được lắp đèn. Và anh ta sẽ trả mọi khoản phí. Người dân cuối cùng đã lựa chọn anh ta. Và một ngày sau ngày bầu cử, người dân đã trình bày quyết định của họ về tuyến đường nào sẽ được chọn. Dĩ nhiên họ không chỉ chọn đoạn đường dài nhất trong thành phố mà họ còn thay đổi tên của chúng để được một đoạn đường dài nhất có thể. Bạn có thể tìm ra độ dài của đoạn phố này không? Để chi tiết hơn, bạn được đưa cho danh sách của các đoạn đường. Cho biết giữa hai điểm chỉ có một đoạn đường duy nhất. Nhiệm vụ của bạn là tìm ra khoảng cách lớn nhất giữa hai điểm trong thành phố.

Đầu vào

Dòng đầu tiên của đầu vào bao gồm 1 số T là số lượng test cases. Dòng đầu tiên của mỗi test case bao gồm số lượng các điểm n với 2 <= n <= 50000. Mỗi đường được đưa ra trên một dòng bởi 2 điểm a, b (1 <= a, b <= n) và độ dài của nó l (0 <= l < 20000).

Đầu ra

Với mỗi testcase, in ra kết quả cần tìm.

Ví dụ

Đầu vào:

Đầu ra:

Bạn có thể tham khảo đề bài tiếng anh và submit tại đây: http://www.spoj.com/problems/BENEFACT/

Phân tích

Ở đây, số lượng điểm tối đa là 50000, do đó ta bắt buộc phải dùng danh sách liên kết. Nếu không thì ta sẽ không thể lưu trữ được dữ liệu đầu vào.

Thuật toán để giải quyết bài toán là: ta sẽ sử dụng thuật toán tìm kiếm theo chiều rộng - BFS 2 lần. Lần thứ nhất, BFS tại 1 điểm bất kì, giả sử là điểm 1. Sau lần này ta sẽ tìm ra điểm ở xa điểm 1 nhất, gọi là idMax. Lần thứ hai, ta sẽ BFS từ điểm idMax. Tiếp tục ta lại tìm được một điểm nằm xa điểm idMax nhất, gọi là idMax2. Khoảng cách giữa idMax và idMax2 là kết quả cần tìm.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 50005;

struct Node
{
    int leng;
    int id;
    Node *next;
};

class List
{
public:
    Node *begin;
public:
    List()
    {
        begin = 0;
    }

    void Add(int id, int leng)
    {
        Node *tmp = new Node;
        tmp->id   = id;
        tmp->leng = leng;

        tmp->next = begin;
        begin = tmp;
    }
};

int Answer;         // Lưu kết quả
int T, N, idMax;
int Distance[MAX];  // Mảng lưu khoảng cách từ điểm bắt đầu BFS đến các điểm còn lại
List MyList[MAX];   // Lưu danh sách đầu vào

int queue[MAX];
int fr, re, leng;

void EnQueue(int u)
{
    queue[re] = u;
    re = (re + 1) % MAX;
    leng++;
}

int DeQueue()
{
    int t = queue[fr];
    fr = (fr + 1) % MAX;
    leng--;
    return t;
}

// tìm ra điểm có khoảng cách xa nhất với điểm bắt đầu BFS
void FindMax()
{
    for(int i = 1; i <= N; i++)
        if(Distance[i] > Answer)
        {
            Answer = Distance[i];
            idMax  = i;
        }
}

// Dùng BFS để tìm khoảng cách từ 1 điểm đến các điểm còn lại
// Lưu vào mảng Distance[]
void BFS(int u)
{
    fr = re    = leng = 0;

    for(int j = 1; j <= N; j++)
        Distance[j] = 0;

    EnQueue(u);
    Distance[u] = 1;

    while(leng > 0)
    {
        int k = DeQueue();
        Node *p = MyList[k].begin;
        int v,l;

        while(p != 0)
        {
            v = p->id;
            l = p->leng;

            if(Distance[v] == 0)
            {
                Distance[v] = Distance[k] + l;
                EnQueue(v);
            }

            p = p->next;
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);

    // comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    cin >> T;

    for(int tc = 0; tc < T; tc++)
    {
        Answer = 0;
        for(int i = 1; i <= N; i++)
            MyList[i].begin = 0;

        cin >> N;

        for(int i = 0; i < N-1; i++)
        {
            int st, ed, leng;
            cin >> st >> ed >> leng;

            MyList[st].Add(ed,leng);
            MyList[ed].Add(st,leng);
        }

        BFS(1);
        FindMax();

        BFS(idMax);
        FindMax();

        // In ra kết quả
        cout << Answer - 1 << endl;
    }

    return 0;
}

SPOJ.COM - Thuật toán bài NAKANJ - Minimum Knight moves

admin@phamvanlam.com — Sun, 25 Sep 2016 06:20:00 GMT

Đề bài:

Tít và Mít là đôi bạn tốt. Tuy nhiên, gần đây họ có cãi cọ nhau trong khi chơi cờ vua. Mít muốn biết số bước đi nhỏ nhất để quân mã xuất phát từ 1 ô để đi đến 1 ô khác trên bàn cờ vua 8×8. Tít rất thông minh nên cậu ta đã nghĩ ra thuật toán và viết ra một chương trình để giải quyết bài toán này. Tít đố Mít có thể làm được như vậy.

Tuy nhiên, Mít rất yếu về lập trình nên mong muốn bạn giúp cậu ấy. Quân mã di chuyển theo hình chữ L, chắc bạn cũng biết nên mình không giải thích nhiều nữa. Quân mã phải di chuyển theo cách trên và không được đi ra khỏi bàn cờ. Hình sau minh hoạ bàn cờ, và cách di chuyển của con mã:

Đầu vào

Có tổng số T test cases. Với mỗi test case, sẽ gồm 2 thành phần. Thành phần thứ nhất là điểm xuất phát của con mã. Và thành phần thứ hai là đích đến của con mã. Mỗi thành phần bao gồm 2 kí tự. Kí tự thứ nhất thuộc 8 kí tự từ 'a' đến 'h'. Kí tự thứ hai thuộc 8 kí tự từ '1' đến '8'.

Đầu ra

In ra số bước tối thiểu mà quân mã cần để đi từ điểm xuất phát đến đích ở các dòng riêng biệt.

Ràng buộc:

1 <= T <= 4096

Ví dụ

Đầu vào:

3 
a1 h8 
a1 c2 
h8 c3

Đầu ra:

6 
1 
4

Bạn có thể tham khảo đề bài tiếng anh và submit code tại: http://www.spoj.com/problems/NAKANJ/

Phân tích

Đây là bài toán tìm đường đi ngắn nhất từ một điểm tới một điểm khác.

Do đó ta sẽ triển khai thuật toán tìm kiếm theo chiều rộng - BFS từ điểm ban đầu. Và lan sang các điểm kề với nó theo 8 hướng mà con mã có thể đi.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 100;

int SR, SC, ER, EC;     // Lưu toạ độ hàng, cột của điểm bắt đầu và kết thúc
int Mark[8][8];         // Đánh dấu vị trí con mã

typedef struct Point
{
    int row, col;
    Point(){};
    Point(int r, int c): row(r), col(c){};
}Point;

// Hàng đợi
Point queue[MAX];

// Lần lượt là thông tin và điểm đầu, điểm cuối và độ dài của hàng đợi
int fr, re, leng;

// Mô tả đường đi của con mã
int drow[] = {-2,-1,1,2, 2, 1,-1,-2};
int dcol[] = { 1, 2,2,1,-1,-2,-2,-1};

// Thao tác Enqueue, và Dequeue với hàng đợi vòng
void EnQueue(Point p)
{
    queue[re] = p;
    re = (re + 1) % MAX;
    leng++;
}

Point DeQueue()
{
    Point p = queue[fr];
    fr = (fr + 1) % MAX;
    leng--;
    return p;
}

void BFS()
{
    fr = re = leng = 0;

    EnQueue(Point(SR, SC));
    Mark[SR][SC] = 0;

    while(leng > 0)
    {
        Point p = DeQueue();

        // Nếu gặp đích rồi thì dừng lại
        if(p.row == ER && p.col == EC) break;

        // Kiểm tra 8 hướng đi có thể của con mã
        for(int i = 0; i < 8; i++)
        {
            int r = p.row + drow[i];
            int c = p.col + dcol[i];

            if(r >= 0 && r < 8 && c >= 0 && c < 8 && Mark[r][c] == -1)
            {
                Mark[r][c] = Mark[p.row][p.col] + 1;
                EnQueue(Point(r, c));
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);

    // Comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    int T;
    cin >> T;

    for(int tc = 0; tc < T; tc++)
    {
        char temp[3];

        // Nhập đầu vào và chuyển sang kiểu int
        cin >> temp;
        SR = temp[0] - 'a';
        SC = temp[1] - '0' - 1;

        cin >> temp;
        ER = temp[0] - 'a';
        EC = temp[1] - '0' - 1;

        for(int i = 0; i < 8; i++)
            for(int j = 0; j < 8; j++)
                Mark[i][j] = -1;

        // Triển khai thuật toán BFS để tìm số bước nhỏ nhất
        // từ vị trí ban đầu đến các vị trí còn lại
        BFS();

        // In kết quả
        cout << Mark[ER][EC] << endl;
    }

    return 0;
}

SPOJ.COM - Thuật toán bài ONEZERO - Ones and zeros

admin@phamvanlam.com — Sun, 25 Sep 2016 05:05:00 GMT

Đề bài:

Ta cần tìm 1 số dương mà dạng biểu diễn của nó trong hệ thập phân bao gồm chỉ toàn số 0, 1 và có ít nhất một số 1, ví dụ: 101. Nếu một số mà không có dạng như vậy thì ta có thể nhân nó với một vài số nguyên dương khác để được một số như vậy.

Đầu vào

Cho một số K là số lượng test case (K cỡ 1000), mỗi test case bao gồm K dòng. Mỗi dòng là một số nguyên n, 1 <= n <= 20000.

Đầu ra

Với mỗi một test case, tìm số nguyên dương nhỏ nhất là bội số của n thoả mãn là nó chỉ bao gồm toàn số 0, 1 và bắt đầu bằng số 1.

Ví dụ

Đầu vào:

Đầu ra:

11101 
11011 
11101

Bạn có thể tham khảo đề bài tiếng anh và submit code tại: http://www.spoj.com/problems/ONEZERO/

Phân tích

Nếu đầu vào là 1 thì suy ra luôn đầu ra là 1. Ở bài toán này ta sẽ dùng thuật toán tìm kiếm theo chiều rộng - BFS. Với trạng thái đầu tiên là số 1.

Với chú ý là: Nếu trạng thái hiện tại là số x, thì 2 trạng thái kề với nó là 10*x và 10*x + 1. Khi đó, đảm bảo rằng các số sẽ chỉ toàn 0 và 1.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 20005;

int  N, Exist[MAX], Parent[MAX];
int  current, expanding, remainder, len;
char Digit[MAX], Temp[MAX];

int queue[MAX];
int fr, re, leng;

void Enqueue(int remainder)
{
    queue[re] = remainder;
    re = (re + 1) % MAX;
    leng++;
}

int Dequeue()
{
    int c = queue[fr];
    fr = (fr + 1) % MAX;
    leng--;
    return c;
}

int main()
{
    ios::sync_with_stdio(false);

    // Comment trước khi submit
    freopen("input.txt","r",stdin);

    int K;
    cin >> K;

    for(int i = 0; i < K; i++)
    {
        cin >> N;

        for(int i = 0; i < N; i++)
        {
            Exist[i] = 0;
            Parent[i]= 0;
            Digit[i] = '0';
            Temp[i]  = '0';
        }

        // Nếu đầu vào là 1 => số cần tìm cũng là 1
        if(N == 1)
        {
            cout << 1 << endl;
            continue;
        }

        // Duyệt tất cả các trạng thái
        Parent[1] = -1;
        Digit[1]  = '1';
        Exist[1]  = 1;

        Enqueue(1);

        while(leng > 0)
        {
            current = Dequeue();

            for(int i = 0; i < 2; i++)
            {
                // xét trạng thái kề với current
                expanding = current * 10 + i;
                remainder = expanding % N;

                if(Exist[remainder] == 0)
                {
                    Exist[remainder]  = 1;
                    Parent[remainder] = current;
                    Digit[remainder]  = i + '0';

                    Enqueue(remainder);
                }
            }
        }

        // Truy lại số cần tìm
        current = 0;
        len    = 0;

        while(true)
        {
            Temp[len++] = Digit[current];

            if(Parent[current] == -1) break;
            else current = Parent[current];
        }

        for(int i = len - 1; i >= 0; i--)
            cout << Temp[i];
        cout << endl;
    }

    return 0;
}

SPOJ.COM - Thuật toán bài ELEVTRBL - Elevator Trouble

admin@phamvanlam.com — Sun, 25 Sep 2016 04:52:00 GMT

Đề bài:

Bạn đang trên đường đi đến buổi phỏng vấn cho vị trí lập trình viên. Và thực tế, bạn đã bị muộn. Buổi phỏng vấn được diễn ra ở một tòa nhà rất cao và bạn đang ở tầng s, nơi mà bạn gặp một chiếc thang máy. Biết rằng, thang máy sẽ có 2 nút bấm được đánh dấu là "UP u" và "DOWN d". Bạn kết luận là nút UP sẽ đưa thang máy lên trên u tầng nếu như có đủ số tầng phía trên, và nút DOWN sẽ đưa thang máy đi xuống d tầng nếu có đủ số tầng phía dưới. Trường hợp không có đủ số tầng thì thang máy sẽ không lên hoặc không xuống. Biết rằng buổi phỏng vấn được diễn ra tại tầng g, và tòa nhà này có f tầng. Bạn hãy nghĩ ra thuật toán và lập trình để tính ra số lần phải bấm nút là ít nhất để đi được đến đúng vị trí tầng phỏng vấn. Nếu không thể đển được đúng tầng thì in ra dòng chữ "use the stairs".

Cho số f, s, g, u và d (lần lượt là số lượng tầng tại tòa nhà, tầng bắt đầu, tầng đích, số tầng lên và số tầng xuống). Tìm ra số lần phải bấm nút ít nhất để đi được từ tầng s đến tầng g và in ra số đó hoặc trong trường hợp không thể đi được thì in ra "use the stairs".

Đầu vào

Đầu vào bao gồm một dòng, chứa các số f s g u d, trong đó 1 <= s, g <= f <= 1000000 và 0 <= u, d <= 1000000. Các tầng được đánh số từ 1. Ví dụ có 10 tầng thì các tầng sẽ là 1, 2, 3,…,10.

Đầu ra

In ra số lần phải bấm nút là ít nhất để đi được từ tầng s đến tầng g. Trường hợp không thể đi được thì in ra dòng chữ "use the stairs".

Ví dụ 1:

Đầu vào:

10 1 10 2 1

Đầu ra:

Ví dụ 2:

Đầu vào:

100 2 1 1 0

Đầu ra:

use the stairs

Bạn có thể tham khảo link gốc đề bài tiếng anh và submit code tại đây: http://www.spoj.com/problems/ELEVTRBL/

Phân tích

Bài toán này ta khó có thể sử dụng thuật toán vét cạn, hay quay lui có điều kiện vì số lượng tầng ở đây có thể lên đến N = 1000000. Như vậy, chắc chắn sẽ bị time limit.

Ta sẽ sử dụng thuật toán tìm kiếm theo chiều rộng - BFS. Tư tưởng ở đây là ta sẽ đi tính số lần bấm nút nhỏ nhất để đi được hết tất cả các tầng.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 1000005;

int f, s, g, u, d;          // Chứa những thông tin với tên trùng với đầu bài cho
int Number[MAX];            // Lưu số lần bấm nút nhỏ nhất để đi đến mỗi tầng

// mảng đóng vai trò là hàng đợi - queue,
// để triển khai thuật toán tìm kiếm theo chiều rộng.
int queue[MAX];
int fr, re, leng;

void Enqueue(int id)
{
    queue[re] = id;
    re = (re + 1) % MAX;
    leng++;
}

int Dequeue()
{
    int t = queue[fr];
    fr = (fr + 1) % MAX;
    leng--;
    return t;
}

void BFS(int start)
{
    fr = re = leng = 0;

    // Cho tầng đầu tiên vào hàng đợi, giá trị số lần bấm nút sẽ là 0
    Number[start] = 0;
    Enqueue(start);

    while(leng > 0)
    {
        // Lần lượt dequeue ra và cập nhật trạng thái mới
        int tmp = Dequeue();

        // Nếu gặp phải tầng đích thì dừng luôn
        if(tmp == g) break;

        // Nếu bấm lên trên
        if (tmp + u <= f && Number[tmp + u] == -1)
        {
            Number[tmp + u] = Number[tmp] + 1;
            Enqueue(tmp + u);
        }

        // Nếu bấm xuống dưới
        if (tmp - d >= 1 && Number[tmp - d] == -1)
        {
            Number[tmp - d] = Number[tmp] + 1;
            Enqueue(tmp - d);
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);

    // comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    // nhập thông tin đầu vào, tên biến giống với đề bài cho
    cin >> f >> s >> g >> u >> d;

    // khởi tạo
    for(int i = 1; i <= f; i++)
        Number[i] = -1;

    BFS(s);

    // Nếu Number[g] == -1 nghĩa là không thể đi được tới tầng g
    if(Number[g] == -1) cout << "use the stairs" << endl;
    else cout << Number[g] << endl;

    return 0;
}

SPOJ.COM - Thuật toán bài PT07Y - Is it a tree

admin@phamvanlam.com — Fri, 23 Sep 2016 22:52:00 GMT

Đề bài:

Bạn được cho một đồ thị không trọng số, và vô hướng. Viết chương trình để kiểm tra xem nó có phải là cây hay không.

Đầu vào

Dòng đầu tiên của đầu vào sẽ bao gồm 2 số nguyên N và M, tương ứng là số lượng các điểm và số lượng cạnh trên đồ thị, với 0 < N <= 10000, 0 <= M <= 20000. Tiếp theo là M dòng chứa thông tin M cạnh của đồ thị. Mỗi dòng bao gồm một cặp u,v, nghĩa là có 1 cạnh giữa 2 điểm u, v với 1 <= u,v <= N.

Đầu ra

In ra "YES" nếu như đồ thị đó là cây, ngược lại in ra "NO".

Ví dụ

Đầu vào:

3 2 
1 2 
2 3

Đầu ra:

YES

Bạn có thể tham khảo đề bài tiếng anh và submit code tại: http://www.spoj.com/problems/PT07Y/

Phân tích

Trước tiên, để giải được bài toán này, bạn phải hiểu thế nào là cây. Theo mình hiểu một cách đơn giản là: cây là một đồ thị liên thông, và không có chu trình nào. Do đó, nếu cây có N đỉnh thì sẽ có đúng N-1 cạnh.

Ta sẽ dùng thuật toán tìm kiếm theo chiều sâu DFS để duyệt đồ thị.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX = 10005;

int  Matrix[MAX][MAX];      // Ma trận lưu trạng thái của đồ thị
bool Visit[MAX];            // Mảng đánh dấu mỗi điểm được thăm hay chưa
int  cnt;                   // Đếm số điểm đi qua trong 1 lần duyệt để biết
                            // đồ thị có liên thông hay không
int  N, M;                  // Lần lượt là số đỉnh và số cạnh

void Try(int u)
{
	Visit[u] = 1;
	cnt++;

	for (int i = 1; i <= Matrix[u][0]; i++)
	{
		int v = Matrix[u][i];
		if(!Visit[v]) Try(v);
	}
}

int main()
{
	ios::sync_with_stdio(false);

	// Comment dòng này trước khi submit
	freopen("input.txt","r",stdin);

	cin >> N >> M;
	if(M == 0) cout << "NO" << endl;
	else
	{
		cnt = 0;

		for(int i = 0; i <= N; i++)
		{
			Visit[i] = false;
			for(int j = 0; j <= N; j++)
				Matrix[i][j] = 0;
		}

		// Tại hàng thứ i trong ma trận,
		// ta sẽ lưu id của những đỉnh kề với đỉnh i
		// Matrix[i][0] lưu số lượng đỉnh kề.
		for(int i = 0; i < M; i++)
		{
			int a, b, m;
			cin >> a >> b;

			m = ++Matrix[a][0];
			Matrix[a][m] = b;

			m = ++Matrix[b][0];
			Matrix[b][m] = a;
		}

		// Nếu số cạnh < số đỉnh trừ 1 thì chắc chắn không phải là cây
		if(M == N-1)
		{
			// Thử duyệt tại một điểm bất kì, ở đây là điểm 1
			Try(1);

			// Khi số cạnh là N - 1 và đi được qua hết N điểm
			// thì chứng tỏ đồ thị liên thông.
			// và không có chu trình. Nên sẽ là cây.
			if(cnt == N) cout << "YES" << endl;
			else cout << "NO" << endl;

		}
		else cout << "NO" << endl;

	}

	return 0;
}

SPOJ.COM - Thuật toán bài ALLIZWEL - ALL IZZ WELL

admin@phamvanlam.com — Fri, 23 Sep 2016 22:38:00 GMT

Đề bài:

Mr.Giang luôn luôn nói "ALL IZZ WELL" mỗi khi anh ấy gặp rắc rối. Vì vậy, bạn bè và mọi người xung quanh luôn luôn cười anh ta. Tuy nhiên, Mr.Giang luôn tin vào niềm tin của mình. Anh ấy tin rằng cụm từ "ALLIZZWELL" sẽ làm mọi việc được giải quyết ổn thoả.

Nhiệm vụ của bạn là tạm bỏ qua câu truyện trên và tìm ra nếu như có đường đi trên ma trận tạo thành câu "ALLIZZWELL". Biết rằng có đường đi từ một cell đến tất cả các cell kề với nó. Hai cell kề nhau nếu chúng chia sẻ cạnh hoặc góc.

Đầu vào

Dòng đầu tiên bao gồm một số T biểu diễn số lượng test case. Dòng đầu tiên của mỗi test case bao gồm 2 số R và C biểu diễn số dòng và số cột của ma trận. Cuối cùng là miêu tả ma trận.

Đầu ra

Với mỗi test case, in ra "YES" nếu như có đường đi tạo thành "ALLIZZWELL". Ngược lại in ra "NO"

Chú ý: - Cẩn thận với test case số 4 - Có một dòng mới sau mỗi test case trong đầu vào

Ràng buộc:

T <= 1000 
R <= 100 
C <= 100

Ví dụ

Đầu vào:

5 
3 6 
AWE.QX 
LLL.EO 
IZZWLL 
1 10 
ALLIZZWELL 
2 9 
A.L.Z.E.. 
.L.I.W.L. 
3 3 
AEL 
LWZ 
LIZ 
1 10 
LLEWZZILLA

Đầu ra:

YES 
YES 
NO 
NO 
YES

Bạn có thể tham khảo đề bài tiếng anh và submit tại đây: http://www.spoj.com/problems/ALLIZWEL/

Phân tích

Bài toán này tương tự như bài toán ABCPATH. Tuy nhiên, đối với bài toán ABCPATH, đường đi là các kí tự phân biệt A, B, C,...Z. Còn với bài toán này, đường đi là "ALLIZZWELL", trong đó các kí tự có thể lặp lại. Do đó, ta phải kiểm tra tất cả các đường đi có thể bắt đầu từ kí tự 'A'.

Đó chính là thuật toán tìm kiếm theo chiều sâu DFS và Vét cạn - Brute Force.

Lời giải

Code C/C++

#include<iostream>
using namespace std;

const int MAX = 105;
const char Array[] = "ALLIZZWELL";

int  R, C;              // Lưu số lượng hàng và cột ở ma trận
int  Answer;            // Lưu kết quả của bài toán
char Matrix[MAX][MAX];  // Ma trận đầu vào
bool Visit[MAX][MAX];   // Đánh dấu trạng thái là thăm hay chưa.

int drow[8] = {-1,-1,0,1,1, 1, 0,-1};
int dcol[8] = { 0, 1,1,1,0,-1,-1,-1};

/*
* row, col lần lượt là hàng và cột đang xét
* current là chỉ số của kí tự hiện tại trong mảng Array[] = "ALLIZZWELL"
* chỉ số bắt đầu từ 0 và cuối cùng là 9
*/
void Start(int row, int col, int current)
{
	// Nếu tìm được đường đi
	if(current == 9)
	{
		Answer = 1;
		return;
	}

	// Kiểm tra 8 hướng kề với ô đang xét
	for(int i = 0; i < 8; i++)
	{
		int r = row + drow[i];
		int c = col + dcol[i];

		/*
		* Ô nhảy được tới phải là ô trong ma trận
		* Chưa được thăm
		* Và là kí tự tiếp theo trong mảng Array[] trên
		*/
		if (r >= 0 && r < R && c >= 0 && c < C &&
			!Visit[r][c] && Matrix[r][c] == Array[current+1])
		{
			Visit[r][c] = true;
			Start(r, c, current+1);
			Visit[r][c] = false;
		}
	}
}

int main()
{
	ios::sync_with_stdio(false);

	// comment trước khi submit
	freopen("input.txt","r",stdin);

	int T;
	cin >> T;

	for(int tc = 0; tc < T; tc++)
	{
		Answer = 0;

		cin >> R >> C;
		for(int i = 0; i < R; i++)
			cin >> Matrix[i];

		for(int i = 0; i < R; i++)
			for(int j = 0; j < C; j++)
				Visit[i][j] = false;

		// Tìm tất cả các kí tự A trong ma trận và tìm đường đi từ đó
		for(int i = 0; i < R; i++)
		{
			for(int j = 0; j < C; j++)
				if(Matrix[i][j] == 'A')
				{
					Visit[i][j] = true;
					Start(i, j, 0);
					Visit[i][j] = false;

					// Nếu đã tìm được đường đi thoả mãn thì thoát luôn.
					if(Answer) break;
				}

			if(Answer) break;
		}

		// In ra kết quả
		cout << endl;
		if(Answer) cout << "YES" << endl;
		else cout << "NO" << endl;
	}
}

SPOJ.COM - Thuật toán bài ABCPATH - ABC Path

admin@phamvanlam.com — Fri, 23 Sep 2016 22:05:00 GMT

Đây là bài đầu tiên trong chuỗi bài ôn luyện thuật toán trên trang spoj.com mà mình đã làm. Và sau đây là đề bài mà mình đã dịch từ tiếng anh sang tiếng việt. Vì mình chủ yếu là tự học tiếng anh, nên có thể dịch nghĩa chưa được chuẩn xác lắm. Mong bạn thông cảm.

Đề bài:

Cho một lưới hai chiều gồm các kí tự. Yêu cầu tìm ra đường đi dài nhất của các kí tự liên tiếp, bắt đầu tại 'A'. Đường đi có thể nhảy từ 1 kí tự trên lưới đến một kí tự khác theo chiều ngang, dọc hay chéo.

Ví dụ: ở hình sau đây, có một vài đường đi từ A đến D, nhưng không có đường nào đi từ A đến E:

Một trong các đường đi từ A đến D là:

Đầu vào

Mỗi test case sẽ bắt đầu với một dòng gồm 2 số nguyên H, W lần lượt là chiều cao, và chiều rộng của lưới, với 1 <= H, W <= 50. Tiếp theo đó là H dòng, mỗi dòng sẽ có W kí tự viết in hoa. Đầu vào kết thúc với H = W = 0.

Đầu ra

Với mỗi test case in ra "Case C: x" (không có dấu ngoặc kép). Trong đó, C là số thứ tự của test case bắt đầu từ 1 và x là độ dài đường đi dài nhất tìm được.

Ví dụ

Đầu vào:

4 3 
ABE 
CFG 
BDH 
ABC 
0 0

Đầu ra:

Case 1: 4

Bạn có thể tham khảo link gốc đề bài và submit code tại đây: http://www.spoj.com/problems/ABCPATH/

Phân tích

Thực ra đây là bài toán tìm đường đi. Ta sẽ tìm tất cả các kí tự 'A' trên lưới, sau đó tìm đường đi từ vị trí đó thoả mãn yêu cầu bài toán - Một chú ý ở đây đó là: nếu chúng ta tìm tất cả đường đi có thể thì khả năng cao sẽ dẫn đến time limit.

Bạn có thể thấy bài toán này có đặc điểm là: khi có 2 đường mà trong quá trình đi của nó cùng đi qua một điểm, thì thực chất 2 đường đó sẽ có độ dài như nhau. Ví dụ có 2 đường cùng đi đến điểm C, thì nghĩa là trước đó cả hai đều phải đi qua điểm A và B.

Vì vậy, với bài toán này ta sẽ sử dụng thuật toán tìm kiếm theo chiều sâu - DFS.

Lời giải

Code C/C++

#include <iostream>
using namespace std;

const int MAX = 51;

int  H;                 // Lưu chiều cao lưới
int  W;                 // Lưu chiều rộng lưới
int  Answer;            // Kết quả đường đi dài nhất
char Matrix[MAX][MAX];  // Lưu lưới các kí tự
bool Visit[MAX][MAX];   // Đánh dấu trạng thái kí tự được thăm hay chưa

int drow[8] = {-1,-1,0,1,1, 1, 0,-1};
int dcol[8] = { 0, 1,1,1,0,-1,-1,-1};

/*
* row : là chỉ số hàng của điểm hiện tại
* col : là chỉ số cột của điểm hiện tại
* leng: là độ dài đường đi hiện tại
*/
void Start(int row, int col, int leng)
{
    // Kiểm tra 8 hướng kề với điểm hiện tại.
    for(int i = 0; i < 8; i++)
    {
        int r = row + drow[i];
        int c = col + dcol[i];

        /*
        * Ô tiếp theo nhảy tới phải thoả mãn điều kiện:
        * Nằm trong ma trận
        * Chưa được thăm
        * Phải là kí tự kế tiếp của kí tự hiện tại theo thứ tự A,B,C,...
        */
        if (r >= 0 && r < H && c >= 0 && c < W &&
            Visit[r][c] == 0 && Matrix[r][c] == Matrix[row][col] + 1)
        {
            Visit[r][c] = 1;
            Start(r, c, leng+1);
        }
    }

    // Khi không thể đi được nữa, ta sẽ cập nhật kết quả
    if(leng > Answer)
    {
        Answer = leng;
    }
}

int main()
{
    ios::sync_with_stdio(false);

    // comment dòng này trước khi submit
    freopen("input.txt","r",stdin);

    int tc = 0;

    while(true)
    {
        // Nhập đầu vào
        cin >> H >> W;
        if(H == 0 && W == 0) break;

        tc++;
        Answer = 0;

        for(int i = 0; i < H; i++)
            cin >> Matrix[i];

        for(int i = 0; i < H; i++)
            for(int j = 0; j < W; j++)
                Visit[i][j] = false;

        // Tìm kiếm kí tự 'A', và bắt đầu tìm đường đi từ đó
        for(int i = 0; i < H; i++)
            for(int j = 0; j < W; j++)
                if(Matrix[i][j] == 'A')
                {
                    Visit[i][j] = true;

                    // Bắt đầu tại điểm có toạ độ (i, j)
                    // và độ dài đường đi lúc này là 1
                    Start(i, j, 1);
                }

        // In kết quả
        cout << "Case " << tc << ": " << Answer << endl;
    }

    return 0;
}

Tổng hợp một số thuật toán cơ bản

admin@phamvanlam.com — Fri, 23 Sep 2016 10:43:00 GMT

Thuật toán kiểm tra một số có phải là số chính phương hay không

Tư tưởng là ta sẽ kiểm tra xem các số m từ 1 đến số a xem nếu m*m = a thì số a là số chính phương. Tuy nhiên ta sẽ sử dụng thuật toán chia đôi để nhanh chóng tìm ra kết quả.

bool IsSquareNumber(int a)
{
    int left = 1, right = a, m;
    while(left < right)
    {
        m = (left + right) / 2;
        if(m*m > a) right = m - 1;
        else if(m*m < a) left = m + 1;
        else return true;
    }

    return false;
}

Thuật toán kiểm tra xem một số có là số nguyên tố hay không

bool IsPrimeNumber(int a)
{
    if(a < 2) return false;

    for(int i = 2; i*i <= a; i++)
        if(a % i == 0) return false;
            return true;
}

Thuật toán tạo một mảng đánh dấu các số nguyên tố không lớn hơn n

bool* CreatePrimeArray(int n)
{
    bool *Prime = new bool[n+1];

    for(int i = 0; i <= n; i++)
        Prime[i] = true;
    Prime[0] = Prime[1] = false;

    for(int i = 2; i*i <= n; i++)
        if(Prime[i] == true)
        {
            int j = 2;
            while(i*j <= n)
            {
                Prime[i*j] = false;
                j++;
            }
        }

    return Prime;
}

Thuật toán tìm ước số chung lớn nhất

Ta sẽ tìm ước chung lớn nhất của hai số dựa vào thuật toán Euclid

int GCD(int a, int b)
{
    if(a == 0 && b == 0) return -1;
    if(b == 0 || a == 0) return a + b;
    return GCD(b, a%b);
}

Thuật toán tìm bội số chung nhỏ nhất

Ta sẽ tìm bội số chung nhỏ nhất dựa vào thuật toán tìm ước số chung lớn nhất như trên

int LCM(int a, int b)
{
    if(a == 0 || b == 0) return -1;
    return (abs(a * b) / GCD(a, b));
}

Thuật toán tính giai thừa: n!

int Factorial(int n)
{
    int r = 1;
    for(int i = 1; i <= n; i++)
        r *= i;
    return r;
}

Thuật toán tính tổ hợp chập k của n: C(k,n)

int Combination(int k, int n)
{
    int r = 1;
    for (int i = 1; i <= k; i++,n--)
        r = r * n / i;
    return r;
}

Tổng hợp một số thuật toán cơ bản về sắp xếp - Phần 2

admin@phamvanlam.com — Fri, 23 Sep 2016 10:42:00 GMT

Trước khi đọc bài này, xin mời bạn tham khảo bài Tổng hợp một số thuật toán cơ bản về sắp xếp - Phần 1. Bài này, mình sẽ giới thiệu với bạn các thuật toán sắp xếp nhanh hơn, có thể giải quyết được những bài toán với số lượng phần tử lớn hơn.

Thuật toán sắp xếp nhanh - Quick Sort

Tư tưởng chính của thuật toán sắp xếp này là: chọn ra một phần tử làm trung gian, phần tử có giá trị nhỏ hơn trung gian thì cho sang bên trái phần tử trung gian, phần tử có giá trị lớn hơn trung gian thì cho sang bên phải phần tử trung gian.

void QuickSort(int *a, int left, int right)
{
    int l = left, r = right;
    int pivot = a[(l + r) / 2];

    while(l <= r)
    {
        while(a[l] < pivot) l++;

        while(a[r] > pivot) r--;

        if(l <= r)
        {
            swap(a[l], a[r]);
            l++;
            r--;
        }
    }

    if(left < r)
        Quick(a, left, r);

    if(l < right)
        Quick(a, l, right);
}

Thuật toán sắp xếp trộn - Merge sort

// Hàm này dùng để trộn 2 phần đã được sắp xếp với nhau
void Merge(int *a, int left, int m, int right)
{
    int l = left, r = m + 1, k = 0;
    int *tmp = new T[right - left + 1];

    while(l <= m && r <= right)
    {
        if(a[l] < a[r]) tmp[k++] = a[l++];
        else tmp[k++] = a[r++];
    }

    while (l <= m) tmp[k++] = a[l++];

    while (r <= right) tmp[k++] = a[r++];

    for(int i = 0; i < k; i++)
        a[i+left] = tmp[i];

    delete[] tmp;
}

// Chia dãy đã cho thành 2 phần cho đến đi không chia được nữa
// Sau khi chia làm 2 phần, sắp xếp từng phần, rồi trộn lại với nhau
void MergeSort(int *a, int left, int right)
{
    int m;
    if(left < right)
    {
        m = (left + right) / 2;
        MergeSort(a, left, m);
        MergeSort(a, m + 1, right);
        Merge(a, left, m, right);
    }
}

Thuật toán sắp xếp vun đống - Heap sort

Thuật toán xếp vun đống và thuật toán sắp xếp trộn ở trên có độ phức tạp là N.Log(N) nên chạy rất nhanh. Với thuật toán này, các phần tử trong mảng được đặt ở vị trí mô tả cây nhị phân đầy đủ. Tức là nếu chỉ số các phần tử là 0, 1, 2,… thì tại phần tử thứ i sẽ có 2 nút con của nó là tại phần tử thứ 2i + 1 và 2i + 2.

// Sắp xếp lại cây, sao cho phần tử cha luôn lớn hơn phần tử con của nó
void Heapify(int *a, int N, int i)
{
    int Left = 2*i + 1, Right = 2*i + 2, Largest;

    if(Left < N && a[Left] > a[i]) Largest = Left;
    else Largest = i;

    if(Right < N && a[Right] > a[Largest]) Largest = Right;

    if(Largest != i)
    {
        swap(a[i], a[Largest]);
        Heapify(a, N, Largest);
    }
}

// Xây dựng mô hình cây nhị phân sao cho phần tử cha luôn lớn hơn phần tử con
void BuildHeap(int *a, int N)
{
    for(int i = N/2-1; i >= 0; i--)
        Heapify(a, N, i);
}

// Hàm chính
void Heap(int *a, int N)
{
    BuildHeap(a, N);

    for(int i = N - 1; i >= 0; i--)
    {
        // cho phần tử lớn nhất xuống dưới cùng,
        // sau đó, cập nhật lại cây
        swap(a[i], a[0]);
        Heapify(a, i, 0);
    }
}

Tổng hợp một số thuật toán cơ bản về sắp xếp - Phần 1

admin@phamvanlam.com — Fri, 23 Sep 2016 10:41:00 GMT

Hôm nay, mình sẽ chia sẻ với bạn một số thuật toán cơ bản về sắp xếp. Những thuật toán sau thường dễ để triển khai, tuy nhiên thì độ phức tạp của chúng là N^2. Vì vậy, những thuật toán này chỉ áp dụng cho những bài toán với số lượng phần tử nhỏ. Với những bài toán có số lượng phần tử lớn thì ta sẽ sử dụng những thuật toán nhanh hơn - sẽ được giới thiệu ở phần sau.

Thuật toán sắp xếp chọn trực tiếp - Selection sort

void SelectionSort(int *a, int N)
{
    for(int i = 0; i < N - 1; i++)
    {
        int idmin = i;

        // Tìm ra phần tử có giá trị nhỏ nhất
        for(int j = i + 1; j < N; j++)
            if(a[j] < a[idmin])
                idmin = j;

        // Đổi chỗ phần tử đầu tiên của dãy còn lại với phần tử nhỏ nhất
        swap(a[i], a[idmin]);
    }
}

Thuật toán sắp xếp chèn trực tiếp - Insertion sort

void InsertionSort(int *a, int N)
{
    int pos, x;

    for(int i = 1; i < N; i++)
    {
        pos = i - 1;
        x = a[i];

        // giả sử dãy a[0], a[1], ... , a[i] đã sắp xếp
        // bắt đầu từ a[i], duyệt về đầu mảng và tìm vị trí thích hợp cho a[i]
        while(pos >= 0 && a[pos] > x)
        {
            a[pos + 1] = a[pos];
            pos--;
        }

        a[pos+1] = x;
    }
}

Thuật toán sắp xếp chèn trực tiếp dựa trên tìm kiếm nhị phân - Binary insertion sort

void BinaryInsertionSort(int *a, int N)
{
    int l, r, m, x;

    for(int i = 1; i < N; i++)
    {
        l = 0;
        r = i - 1;
        x = a[i];

        // Tương tự như Insertionsort nhưng ở đây
        // ta dựa vào tìm kiếm nhị phân để xác định
        // vị trí phù hợp cho a[i] được nhanh hơn
        while (l <= r)
        {
            m = (l + r) / 2;
            if(a[m] > x) r = m - 1;
            else l = m + 1;
        }

        for(int j = i; j > l; j--)
            a[j] = a[j-1];

        a[l] = x;
    }
}

Thuật toán sắp xếp đổi chỗ trực tiếp - Interchange sort

void InterChangeSort(int *a, int N)
{
    for(int i = 0; i < N - 1; i++)
        for(int j = i + 1; j < N; j++)
            if(a[j] < a[i])
                swap(a[j], a[i]);
}

Thuật toán sắp xếp nổi bọt - Bubble sort

void BubbleSort(int *a, int N)
{
    for(int i = 0; i < N-1; i++)
        for(int j = N-1; j > i; j--)
            if(a[j] < a[j-1])
                swap(a[j], a[j-1]);
}

Thuật toán sắp xếp Shaker sort

void ShakerSort(int *a, int N)
{
    // Thuật toán cải tiến thuật toán sắp xếp nổi bọt
    // Bình thường khi ta sắp xếp nổi bọt, giả sử tăng dần
    // Thì phần tử nhỏ nhất sẽ được dồn về trái, dần dần cho đến hết.
    // Còn với thuật toán này ta sẽ dồn phần tử nhỏ nhất về trái, phần tử lớn lớn sang phải đồng thời
    int left, right, k;

    left = 0;
    right = N-1;
    k = N-1;

    while(left < right)
    {
        for(int j = right; j > left; j--)
        {
            if(a[j] < a[j-1])
            {
                swap(a[j], a[j-1]);
                k = j;
            }
        }
        left = k;

        for (int j = left; j < right; j++)
        {
            if (a[j] > a[j+1])
            {
                swap(a[j], a[j+1]);
                k = j;
            }
        }
        right = k;
    }
}