Đây chắc là một trong những bài viết được chờ đợi nhất sau kì thi HSGSO 2017 vừa rồi. Ngoài chữa bài, mình sẽ đưa ra một số thống kê về đề và lượng người giải được!

Phần chữa bài được thực hiện bởi mình và bạn Nguyễn Đinh Quang Minh. Nếu có câu hỏi gì bạn có thể hỏi mình hoặc Minh qua facebook.

Đề bài

Các bạn có thể tải về đề bài tại đây (mirror). Trong phần comment của link cũng có chữa tóm tắt một vài bài do các bạn của dự tuyển Tổng Hợp.

Lời giải

Mục lục

Ngày 1

1. number
2. race
3. tree
4. inversion

Ngày 2

1. matrix
2. string
3. p2grp
4. turtle

number

• Author: thầy Phương, Phạm Cao Nguyên

• Tester: Nguyễn Hoàng Hải Minh

  Các subtask nhỏ

• Subtask 1 (\(S \le 20\)) có thể dễ dàng giải bằng thuật quay lui, thử tất cả các trường hợp cắt với độ phức tạp \(O(M1 \times M2 ... \times M_N)\).

• Subtask 2 (\(S \le 500, K \le 18\)): Do giới hạn của \(K\), đáp số là một số không quá giới hạn long long, vì vậy ta có thể thực hiện đơn giản phép quy hoạch động. Gọi \(f[i][j]\) là số lớn nhất có thể tạo được nếu ta sử dụng các đoạn từ 1 đến \(i\) và lấy tổng cộng \(j\) chữ số. Hiển nhiên \(f[0][0] = 0\). Ta có: \[f[i][j] = \sum\limits_{k=0}^{\min(M_i, j)} f[i – 1][j – k] \times 10^k + \overline{A_{i,1}A_{i,2}...A_{i,k}}\] Đáp số chính là \(f[N][K]\). Lưu ý độ phức tạp của thuật toán này chỉ là \(O(SK)\) chứ không phải \(O(N^2K)\).

Tham lam 1 chữ số

Subtask 3 có một giới hạn khá lạ: Mỗi đoạn có độ dài đều là 1. Như vậy, việc chọn một đoạn chỉ đơn giản là lấy hoặc không. Ta có thể ra một thuật toán tham lam cho subtask này.

Ta có thể thấy, ở mỗi vị trí từ trái sang phải ta sẽ luôn ưu tiên số lớn nhất ở trước. Thật vậy, dễ dàng chứng minh điều này: Khi so sánh 2 số có cùng độ dài, ta chỉ cần tìm chữ số đầu tiên khác nhau từ trái sang và so sánh chúng.

Ý tưởng tham lam như sau. Giả sử ta đã lấy \(x\) chữ số, chữ số cuối cùng ta lấy ở vị trí \(i\). Ta có các nhận xét sau về chữ số tiếp theo cần lấy (ở vị trí \(j\)): – Hiển nhiên ta không thể lấy tiếp ở các vị trí \(j \le i\). – Hiển nhiên không kém, ta không thể lấy ở các vị trí \(j > N – (K – x) + 1\). Đơn giản là, nếu lấy ở các vị trí này, ta không còn đủ chữ số để dựng số có \(K\) chữ số nữa. – Trong các vị trí còn lại, ta luôn chọn vị trí có chữ số lớn nhất. Điều này hiển nhiên đúng, vì về sau ta chọn thế nào thì cũng ra số lớn hơn số được tạo ra nếu ta không chọn chữ số lớn nhất ở bước này. – Trong các vị trí có cùng giá trị, lấy vị trí trái nhất. Điều này đảm bảo ta có nhiều cơ hội hơn để lấy số lớn hơn ở vị trí tiếp theo.

Như vậy subtask 3 có thể giải với độ phức tạp \(O(10 \times N)\). Hãy lưu ý subtask này, vì ý tưởng tham lam là chìa khóa để giải subtask cuối!

Cải tiến quy hoạch động

2 subtask tiếp theo (4 và 5) chỉ là việc cài đặt công thức quy hoạch động của subtask 2 lên với số lớn. Dễ dàng nhận thấy ta chỉ phải cài đặt phép cộng số lớn, và đáp số không quá \(10^K\) nên độ phức tạp là \(O(SK^2)\).

Dễ dàng cài số lớn qua subtask 4, nhưng để qua subtask 5 sẽ cần thêm một chút cải tiến để lọt time limit (vd nén 9 chữ số vào một int thay vì giữ từng chữ số, cộng dồn đoạn để giảm số phép tính,...)

Subtask cuối

Để giải được subtask cuối, ta cần bỏ đi suy nghĩ quy hoạch động và quay lại với ý tưởng tham lam.

Tại sao ý tưởng của subtask 3 không thể áp dụng được ngay vào subtask cuối? Bởi vì trong mỗi đoạn, ta bắt buộc phải chọn 1 đoạn tiền tố để đặt vào đáp số. Nhiều khi, chữ số phía sau lớn nhưng đoạn chữ số phía trước không tối ưu.

Ta có thể chỉ xét chữ số tiếp theo của chuỗi đang lấy cuối cùng, hoặc đầu của các chuỗi phía sau. Đây là một nhận xét đúng. Thật vậy: Kiểu gì bạn cũng phải đặt chữ số đầu tiên của một chuỗi nếu lấy chuỗi đó. Và nếu chữ số đầu tiên có lựa chọn tốt hơn: điều đúng đắn là bỏ cả chuỗi.

Tuy nhiên, có một vấn đề khác. Khi có nhiều lựa chọn chữ số tiếp theo giống nhau, chọn chữ số trái cùng không phải lựa chọn tối ưu. Bản chất là vì lựa chọn của bạn còn làm ảnh hưởng đến tập đáp số tối ưu phía sau:

• Nếu \(M_i = 1\) với mọi \(i\), lựa chọn của bạn luôn là \((x_j, y_j)\) (giá trị, vị trí) với chữ số \(j\) (từ trái sang) và \(j\) luôn tốt hơn \(j + 1\).
• Khi điều kiện 1 không còn nữa, không phải lúc nào \(j\) cũng tốt hơn \(j + 1\). Xét trường hợp sau: 5 6 và 5 7 (\(K = 2\)). Nếu bạn chọn số 5 bên trái, tiếp theo bạn chỉ được chọn giữa 6 và 5 cho chữ số tiếp theo. Trong khi đó đáp số hiển nhiên là 57.

Tuy vậy, ta nhận thấy đáp án tối ưu vẫn luôn xuất phát từ chữ số lớn nhất, và đáp án vẫn là chọn số lớn nhất có thể ở mỗi bước. Vậy ta vẫn có thể đưa số 5 vào, chỉ có điều ta chưa quyết định đấy là số 5 ở vị trí nào. Hay hiểu kiểu khác, trước tiên ta chọn 5 của 5 6, nhưng do 5 7 có đầu 5 trùng với đuôi 5 của ta nên ta xóa 5 của 5 6 đi và thêm cả 5 7 vào.

Tóm tắt lại, thuật toán của ta như sau: Giả sử ta đã có \(i\) chữ số \(x_1, x_2, ..., x_i\) (\(x_i\) ở dãy \(j\)), ta sẽ có tập lựa chọn cho chữ số tiếp theo (dãy \(p\) vị trí \(q\)) như sau: – Nó phải thuộc dãy \(p \ge j\). Hiển nhiên ta không thể lấy lại một dãy trước đó. – Sau nó phải có ít nhất \(K – i – 1\) chữ số (từ nó về cuối dãy, và tổng tất cả dãy phía sau). – \(p = j\) và nó là chữ số đứng sau \(x_i\), hoặc – \(p > j\), \(x_{i – k} = A[p][q – 1 – k]\) với mọi \(0 \le k < q – 1\). Khi chọn lựa chọn này, ta xóa tất cả \(x_{i – q + 2}..x_i\) và thêm vào \(A[p][1..q]\).

Dễ dàng chứng minh ở mỗi bước, ta đều lấy được chữ số lớn nhất có thể lấy được khi có prefix dựng từ bước trước đó (do vậy, nếu prefix tối ưu thì theo phép so sánh số, dãy mới là tối ưu). Do ở bước đầu (prefix rỗng), lựa chọn là tối ưu, nên theo quy nạp thuật toán tham là tối ưu.

Ta có thể cài thuật toán này trong độ phức tạp \(O(SK)\).

Một chút thống kê

Về điểm số: – Có một bạn duy nhất được 99 điểm (Bùi Hồng Đức). Xin chúc mừng Đức đã ra được thuật toán đúng cho subtask cuối. Thật vậy, Đức chỉ còn 1 test lắt léo duy nhất: Đề bài yêu cầu in ra số tạo từ \(K\) chữ số đã chọn, mà đã là số thì phải không có số 0 ở đầu :( Kể ra bài đã khó, test cũng khó, sorry mọi người vì cái test quái gở này. – Có 12 bạn được 73-76 điểm. Khi sinh test mình đã tính đến việc các bạn sử dụng tham lam của subtask 3, đưa thẳng vào subtask 6 (chỉ qua nhận xét đầu tiên). Đây là số điểm các bạn nhận được :) Kể ra không cho điểm nào thì cũng hơi ác, nhưng cho nhiều điểm quá thì cũng không đáng (nhớ rằng tối ưu bignum chỉ được thêm 10 điểm). Thật sự 6 điểm khá là nhiều cho một thuật sai khá là rõ ràng, và còn vài bạn còn cài sai thuật đó nữa... – 6 bạn được 70 điểm. Chúc mừng 6 bạn đã qua được mốc quan trọng của một bài khó: cắn nhiều nhất có thể. Đây là chiến thuật hữu dụng nhất khi thi quốc gia! – Còn lại 71 bạn có điểm dương, trải dài khá đều từ 1 đến 65 điểm. Rất tuyên dương cố gắng của các bạn! Hãy cố lên! Đặc biệt với những bạn được 1 điểm, mình không hiểu tại sao có thể được 1 điểm...

Về bộ test: – Bản thân mình khá hài lòng về bộ test mình sinh ra. Có đủ điểm cho người liều lĩnh, đủ điểm cho người chắc ăn, đủ lỗi để hành người sai,... – Trong bộ test (sau này sẽ được up), có 2 test được sinh ra để giết một nhận xét tham lam của subtask 6... Đố bạn nào biết đó là nhận xét gì :)

race

• Author: Nguyễn Đinh Quang Minh
• Tester: Nguyễn Hoàng Hải Minh

Bài toán lớp bốn và thuật toán O(N^3)

Ba người \(A\), \(B\), \(C\) xuất phát ở ba vị trí \(x_A\), \(x_B\), \(x_C\) trên một đường thẳng, cùng đi về một hướng với vận tốc \(v_A\), \(v_B\), \(v_C\). Hỏi có thời điểm nào người \(B\) nằm ở trung điểm 2 người còn lại hay không?

Thầy Phương từng đố mình bài toán trên. Nếu bỏ qua dữ kiện ‘đây là bài toán lớp bốn’ thì chúng ta (tất nhiên kể cả mình) đều sẽ cầm bút giải phương trình bậc nhất rồi tìm nghiệm. Nhưng hãy thử nghĩ như một học sinh lớp bốn xem sao…

Cách giải của các bé lớp bốn cho bài toán này như sau: giả sử có thêm một người \(D\) di chuyển sao cho \(D\) luôn nằm ở trung điểm của \(A\) và \(C\), khi đó nếu \(B\) gặp \(D\) tức là \(B\) nằm ở trung điểm \(AC\). Vị trí xuất phát và vận tốc của \(D\) như thế nào cho hợp lý? Hiển nhiên là trung bình cộng của \(A\) và \(C\), tức là \(x_D = \dfrac{x_A + x_C}{2}\), \(v_D = \dfrac{vA + vC}{2}\).

Khi đã có người D rồi thì có 3 trường hợp xảy ra:

1. \(B\) luôn chạy trùng với \(D\): có vô hạn thời điểm thỏa mãn;
2. \(B\) không gặp \(D\) (kết quả tăng 0);
3. \(B\) có gặp \(D\) (kết quả tăng 1).

Điều kiện cụ thể cho từng trường hợp xảy ra như sau:

Như vậy thuật giải \(O(N^3)\) chỉ đơn giản là duyệt tất cả các bộ ba phân biệt rồi kiểm tra theo bảng trên.

Điều kiện trên nhìn quen quen?

Để tối ưu thuật toán, ta sẽ nghĩ đến việc duyệt 2 người \(A\) và \(C\), tính được thông tin người \(D\), rồi tìm số người \(B\) thỏa mãn. Cụ thể hơn: – Nếu tồn tại người B sao cho xB = xD, vB = vD thì trả về kết quả là infinity. – Cộng vào kết quả số người B thỏa mãn \(x_B \le X_D\), \(v_B > v_D\). – Cộng vào kết quả số người B thỏa mãn \(x_B \ge x_D\), \(v_B < v_D\).

Hai điều kiện trên (trừ điều kiện in ra infinity rất dễ) đều khá quen thuộc: ý tưởng của nó giống với bài polylines của năm ngoái. Ta có thể sort tất cả những người \(B\) và \(D\) theo chiều \(v\) tăng dần rồi sử dụng cấu trúc dữ liệu BIT cho chiều \(x\).

Không biết cài BIT thì sao?

Thì bạn nên học cài BIT ta sẽ thử một thuật giải không sử dụng BIT mà sẽ sử dụng IT.

Trước hết, chúng ta chỉ quan tâm đến giá trị \(x\) và \(v\) của mỗi người đứng thứ mấy nên ta hoàn toàn có thể sort các giá trị \(x\) và \(v\) lại rồi “đánh số” lại theo thứ tự của giá trị trong dãy được sort. Bây giờ khi có một người \(D\) nào đó, ta có thể biết \(x_D\) đứng ở vị trí thứ mấy trong mảng \(x\) bằng chặt nhị phân, tương tự với \(v_D\). Điều này sẽ giúp ta giải quyết bài toán bằng mảng cộng dồn 2 chiều thay vì BIT.

Trước hết, ta lập một mảng \(A[1..N][1..N]\), \(A[i][j] = 1\) có nghĩa là tồn tại một người có giá trị \(x\) đứng thứ \(i\) và giá trị \(v\) đứng thứ \(j\), ngược lại \(A[i][j] = 0\). Giả sử xét một người \(D\) có \(x_D\) đứng ở vị trí thứ \(X\), \(v_D\) đứng ở vị trí thứ \(V\). Như vậy, số người thỏa mãn \(x_B \le x_D\), \(v_B > v_D\) chính là tổng các số trong hình chữ nhật con có góc trên trái là \((1, V)\), góc dưới phải là \((X, N)\) và được tính trong \(O(1)\) bằng mảng cộng dồn.

One more thing

Để cài đặt cho tiện, bạn nên nhân đôi tất cả tọa độ và vận tốc lên ¯\_(ツ)_/¯

Score Distribution!

tree

• Author: Phạm Đức Thắng
• Tester: Nguyễn Hoàng Hải Minh

\(N = 1\)!

Trước tiên, cần phải để ý nếu \(N = 1\) thì đỉnh duy nhất phải có bậc 0. Khi đó, đường đi dài nhất là 1.

Rất nhiều bạn đã chết test này!

Subtask nhỏ

• Subtask 1 (\(N \le 15\)), bạn có thể backtrack mọi cách dựng cây?

Dựng được cây không?

Điều kiện sau là điều kiện cần và đủ để tồn tại cây: – Tổng bậc là \(2N – 2\) – Không đỉnh nào có bậc quá \(N – 1\). – Không đỉnh nào có bậc dưới \(1\).

Dễ dàng chứng minh điều kiện này bằng quy nạp.

Subtask 2 sinh ra để bạn kiểm tra việc dựng cây nếu không biết điều này :D

Dựng tối ưu!

Gọi \(x\) là số nút có bậc lớn hơn 1 (tức không phải lá). Ta sẽ chứng minh nếu \(N \ge 2\) thì đáp số là \(x + 1\).

Thật vậy, ta gọi tập đỉnh không phải lá là \(A_1, A_2, ..., A_x\). Trước tiên, dựng tập cạnh như sau:

lá - A[1] - A[2] - ... - A[x] - lá

Dễ dàng nhận thấy tổng bậc còn lại của các đỉnh không phải lá là \((2N – 2) – (N – x) – 2x = N – x – 2\), số lá còn lại là \(N – x – 2\). Như vậy ta có thể thêm lá vào các bậc còn thiếu của từng đỉnh. Cây đã dựng xong! Đường đi dài nhất trên cây này chắc chắn là \(x + 1\).

Không khó để chứng minh đáp số không thể lớn hơn \(x + 1\) (đường đi đơn không thể đi qua 3 lá). Vì vậy \(x + 1\) là đáp án tối ưu.

Phân bố điểm

Rất nhiều bạn AC bài này, tuy nhiên cũng rất nhiều người bị 98 điểm do thiếu \(N = 1\). Hãy cẩn thận với những trường hợp biên!

inversion

• Author: Nguyễn Thành Vinh
• Tester: Nguyễn Hoàng Hải Minh

Chạy trâu!

For từng đoạn con, tính cặp nghịch thế trâu, \(O(N^4)\) ăn sub 1. Ta có thể cải tiến hơn, tính nghịch thể trong \(O(N \log N)\) bằng BIT, tuy nhiên vẫn chưa đủ để ăn subtask 2.

Tịnh tiến Level 1

Nhận thấy, mỗi lần for đoạn con là một lần tính lại. Đoạn \((i, j)\) chỉ khác đoạn \((i, j + 1)\) một lượng là số phần tử trong khoảng \((i, j)\) mà lớn hơn \(A[j + 1]\). Như vậy, ta có thể for \(i\) rồi vừa tăng \(j\) vừa tính thêm, giảm độ phức tạp xuống \(O(N^2 \log N)\).

Tịnh tiến Level 2

Từ việc tịnh tiến trên, ta nhận thấy rằng nếu \(i \le j < k\) thì \((i, j)\) luôn có số nghịch thế không quá số nghịch thế của \((i, k)\).

Đồng thời, nhận xét cũng đúng với \((j, i)\) và \((k, i)\) nếu \(k < j \le i\).

Giả sử \(j\) là số lớn nhất sao cho \((i, j)\) có số nghịch thế \(< K\). Dễ dàng nhận thấy tất cả \((i, j')\) với \(j < j' \le N\) đều là đáp án. Như vậy với mỗi \(i\) ta chỉ cần tìm \(j\) là đủ.

Lại có \((i, j)\) có số nghịch thế \(< K\), vì thế \((i + 1, j)\) chắc chắn có số nghịch thế \(< K\). Ta không cần for các giá trị nhỏ hơn \(j\) để kiểm tra nữa. Thay vì for lại \(j\), ta xóa \(i\) khỏi đoạn, giảm số nghịch thế đi 1 lượng là số số nhỏ hơn \(A[i]\).

2 con trỏ \(i\) và \(j\) đều tăng từ 1 đến \(N\), mỗi lần tăng con trỏ phải update mất \(O(\log N)\). Độ phức tạp của thuật toán là \(O(N \log N)\).

Phân bố điểm

Đây là một bài khá cơ bản, dù vậy điểm khá là thấp so với bọn mình kì vọng, chủ yếu mọi người chỉ dừng ở subtask 2.

matrix

• Author: Nguyễn Đinh Quang Minh
• Tester: Phạm Cao Nguyên, Nguyễn Hoàng Hải Minh

Các subtask nhỏ

• Subtask 1 (\(N = 1\)), đây là subtask cho điểm vì bản thân cả bảng đã được chứa trong mảng \(B[]\). Nếu xor tất cả phần tử trong mảng \(B[]\) bằng \(A[1]\) thì có 1 đáp án chính là mảng \(B[]\). Nếu không thì không có đáp án nào cả. Độ phức tạp \(O(M)\).
• Subtask 2 (\(NM \le 20\)), từ điều kiện ta suy ra \(\min(N, M) \le \sqrt{20} \le 5\). Không mất tính tổng quát ta giả sử \(M \le 5\) (nếu không ta xoay bảng lại), ta có thể quy hoạch động \(f[i][mask]\) là số cách tạo các hàng từ 1 đến \(i\), với tổng xor từng cột được biểu diễn trong \(mask\). Sau đó ta có thể for tất cả các mask \(m\) có thể của hàng \(i + 1\), update vào \(f[i + 1][mask \oplus m]\). Độ phức tạp là \(O(N \times (2^M)^2)\). Hoặc ta có thể backtrack giá trị của tất cả phần tử của bảng, độ phức tạp là \(O(2^{N + M})\).
• Subtask 3 (\(N \le 10\), \(M \le 2000\)), ta sẽ cải tiến thuật toán quy hoạch động phía trên. Thay vì mỗi lần ta thêm cả cột (mất \(O(2^N)\)), ta chỉ thêm từng ô. Gọi \(f[i][j][mask]\) là số cách điền các ô từ \((i, j)\) trở đi (theo từng cột, rồi từng hàng), và xor các phần tử đã đặt vào trước đó của mỗi hàng được biểu diễn trong mask. Ta tính từ \(f[i + 1][j][mask']\) hoặc \(f[1][j + 1][mask']\), với điều kiện là khi điền xong mỗi cột thì xor cột đó phải bằng \(B[j]\). Ta có thể kiểm tra điều này bằng cách kiểm tra \(X = B[1] \oplus B[2] \oplus ... \oplus B[j]\) có bằng xor các bit trong \(mask\) không. Độ phức tạp là \(O(NM2^N)\).

Dựng một đáp án

Trước khi tìm hiểu xem có bao nhiêu đáp án thỏa mãn, ta cần phải kiểm tra xem có tồn tại đáp án không đã.

Hiển nhiên nếu tổng xor của \(A[]\) khác tổng xor của \(B[]\) thì không thể tồn tại bảng thỏa mãn. Còn lại, ta sẽ chứng minh luôn tồn tại bảng thỏa mãn.

Gọi tổng xor cả bảng là \(S\).

Xét bảng \(N \times M\) được dựng như sau:

• Với \(i < N\) và \(j < M\): điền 0.
• Với \(i = N\) và \(j < M\): điền \(B[j]\).
• Với \(i < N\) và \(j = M\): điền \(A[i]\).
• Xét ô \((N, M)\). Ta có giá trị \(b[N][M] = A[N] \oplus B[1] \oplus B[2] \oplus ... \oplus B[M – 1]\), hay \(b[N][M] = A[N] \oplus S \oplus B[M]\). Tất nhiên phân tích theo cột ta cũng sẽ ra công thức này, và vì \(S\) xác định nên có duy nhất 1 cách điền ô \((N, M)\).

Vậy tồn tại bảng thỏa mãn.

Có bao nhiêu bảng thỏa mãn?

Giả sử ta có bảng \(b[][]\) thỏa mãn.

Nếu ta flip giá trị \(b[i][j]\) (\(i < N\), \(j < M\)), ta có thể flip cả \(b[i][M]\), \(b[N][j]\) và \([N][M]\) để ra một bảng mới vẫn đúng. (mỗi hàng mỗi cột ảnh hưởng đều bị flip tổng xor 2 lần).

Nếu ta giữ nguyên \(b[i][j]\) với mọi \(i < N\) và \(j < M\), dễ dàng chứng minh cách điền các ô còn lại là duy nhất. Thật vậy, \(b[i][M]\) (\(i < M\)) phải xác định duy nhất để tổng xor các ô trong hàng \(i\) bằng \(A[i]\), tương tự với \(b[N][j]\) (\(j < N\)). Còn lại ô \((N, M)\), tất nhiên vì hàng và cột cuối cũng có tổng xor xác định nên giá trị của ô cũng chỉ có tối đa một.

Từ 2 nhận xét trên, ta thấy với mỗi cách điền bảng \((N – 1)\times (M – 1)\) ở góc trái trên ta có duy nhất 1 cách điền nốt thỏa mãn. Vậy số bảng thỏa mãn là \(2^{(N – 1)(M – 1)}\).

Kiểm tra điều kiện tồn tại mất \(O(N + M)\), tính số bảng mất \(O(\log(NM))\), dựng 1 bảng thỏa mãn mất \(O(NM)\).

Thống kê

Subtask 2 là một subtask rất đơn giản (backtrack lấy 20 điểm), vậy mà số bạn làm được khá là ít. Subtask 3 đòi hỏi kỹ thuật quy hoạch động khó hơn, không nhiều bạn làm được.

Chúc mừng 4 bạn làm được 100 điểm!

string

• Author: Vương Hoàng Long
• Tester: Nguyễn Hoàng Hải Minh

Subtask nhỏ

Do độ dài của 2 xâu không quá \(10^8\) nên ta có thể thực hiện for trâu để giải subtask này. Tất nhiên có một số điều sau phải chú ý:

• Tuyệt đối không dựng cả xâu. Dựng xâu mất thời gian hằng số rất lớn, có thể làm bạn bị TLE trước cả khi thực hiện so sánh. Chỉ for các chỉ số lặp lại.
• Để tăng tốc, không dùng phép mod để tính nhanh chỉ số.

Độ phức tạp là \(O(|A|)\).

Subtask lớn

Để đơn giản cho việc mod ta coi xâu đánh số từ 0.

Nhận thấy phần tử thứ \(i\) của xâu \(X\) sẽ được so sánh với các phần tử \(i \mod |Y|, (i + |X|) \mod |Y|, ..., (i + (n – 1)|X|) \mod |Y|\) của \(Y\).

Không khó để nhận ra dãy này có chu trình độ dài \(|Y| / \gcd(|X|, |Y|)\). Không khó để chứng minh điều này: \(|X||Y| / \gcd(|X|, |Y|)\) chính là bội chung nhỏ nhất của \(|X|\) và \(|Y|\), bội dương đầu tiên của \(|X|\) chia hết cho \(|Y|\).

Như vậy, ta chỉ cần chia \(Y\) thành các chu trình tương ứng, sau đó tính trước số kí tự từng loại là có thể so sánh 1 vị trí của \(X\) với 1 chu trình trong \(O(1)\).

Độ phức tạp là \(O(|Y| + |X|)\).

Thống kê

Đây là bài dễ của ngày 2. Tuy vậy mình không nghĩ là có ít người AC như vậy. Có lẽ tại vì không nhiều người biết đến việc chu trình BCNN?

p2grp

• Author: Nguyễn Khánh
• Tester: Nguyễn Hoàng Hải Minh

Subtask 1

Với \(n\) và \(m\) không quá 20, các cạnh không quá \(2^{m-1}\), chúng ta có thể dựng đồ thị rồi sử dụng thuật toán tìm đường đi ngắn nhất bất kì (Floyd, Dijkstra hoặc thậm chí là backtrack). Kết quả không vượt quá số nguyên 64 bit nên cũng không có gì bận tâm về cách cài đặt.

Subtask 2

Thuật toán Floyd tìm đường đi ngắn nhất cho mọi cặp đỉnh chạy trong độ phức tạp \(O(n^3)\) nên hoàn toàn có thể vượt qua subtask này. Tuy nhiên, kết quả không còn đủ nhỏ để lưu dưới dạng số nguyên nữa, vì vậy ta cần cài thêm hàm cộng 2 dãy nhị phân.

Subtask 3

Tất nhiên, ngoài Floyd, chúng ta có thể chạy thuật toán Dijkstra từ mỗi đỉnh của đồ thị. Mỗi lần chạy Dijkstra có độ phức tạp \(O((n+m) * \log n)\), nên tổng độ phức tạp sẽ là \(O(n(n+m)\log n \times C)\), trong đó \(C\) là chi phí cộng 2 dãy nhị phân.

Nếu cộng từng bit một của 2 dãy nhị phân lại với nhau thì \(C\) sẽ rơi vào khoảng 1000 phép tính, không đủ để qua subtask này. Cách tốt hơn là cứ \(x\) bit của dãy nhị phân, ta nhóm lại thành một số rồi thực hiện cộng (hiệu quả nhất là \(x = 63\)).

Subtask 4

Điều kiện \(m < n\) cho ta biết đồ thị là một cây. Giữa 2 đỉnh bất kì trên cây chỉ có duy nhất một đường đi đơn, và hiển nhiên đó là đường đi ngắn nhất.

Việc duyệt qua mỗi cặp đỉnh rồi tính đường đi ngắn nhất có vẻ không hiệu quả và cũng khó tối ưu được. Do đó chúng ta nghĩ đến việc thay đổi bài toán: > Với mỗi cạnh, có bao nhiêu cặp đỉnh mà đường đi ngắn nhất đi qua cạnh đó?

Hiển nhiên nếu ta trả lời được câu hỏi trên thì sẽ dễ dàng tính được đáp án.

Câu trả lời thực ra cũng rất đơn giản. Mỗi cạnh trên cây, nếu cắt đi sẽ tạo ra 2 cái cây nhỏ. Dễ thấy một cặp đỉnh mà mỗi đỉnh nằm ở một cây thì đường đi giữa chúng bắt buộc phải đi qua cạnh vừa bị cắt. Do vậy số cặp đỉnh có đường đi đi qua cạnh đó sẽ bằng tích độ lớn 2 cây con.

Ta đặt gốc cây ở đỉnh 1. Giả sử cạnh đang xét nối giữa đỉnh \(u\) và cha của nó, thì 1 trong 2 cây con sẽ chính là cây con gốc \(u\). Việc tính độ lớn cây con gốc u có thể giải quyết bằng DFS trong thời gian \(O(n)\).

Những cạnh không quan trọng

Đọc kĩ lại đề bài, chúng ta phát hiện ra còn một chi tiết nữa mà cả 4 subtask trước đều chưa phải dùng đến: các cạnh có độ lớn \(2^w\) và có trọng số phân biệt. Liệu đây có phải mấu chốt để giải quyết subtask cuối?

Để ý rằng trọng số của một cạnh lớn hơn hẳn tổng trọng số của các cạnh nhỏ hơn nó (vì \(2^0 + 2^1 + ... + 2^{x-1} < 2^x\)). Điều đó chứng tỏ nếu 2 đường đi có cạnh lớn nhất khác nhau thì đường đi nào có cạnh lớn nhất nhỏ hơn chắc chắn có tổng nhỏ hơn.

Như vậy, ta có thể lần lượt các cạnh vào đồ thị theo thứ tự trọng số tăng dần. Giả sử khi thêm cạnh \((u, v)\) mà giữa \(u\) và \(v\) đã có đường đi thì cạnh \((u, v)\) sẽ không nằm trong bất kì đường đi ngắn nhất nào (thay vì đi cạnh \((u, v)\) ta có thể đi đường đi ngắn nhất từ \(u\) đến \(v\) đã tìm được trước đó). Do đó, ta có thể bỏ cạnh \((u, v)\).

Subtask 5 = Subtask 4 ?? :D ??

Sau khi loại bỏ các cạnh không quan trọng, đồ thị ta thu được là một cây (!). Lí do là ta sẽ không thêm cạnh \((u, v)\) mà \(u\) đã có đường đi tới \(v\), tức là đồ thị sẽ không thể có chu trình. Đến đây thì subtask 5 có thể giải y hệt subtask 4 rồi :D

Thống kê

Đây là một bài khá lằng nhằng để ăn điểm những sub nhỏ, nhưng thuật toán chuẩn không cần quá nhiều chi tiết cài đặt. Vì thế bài có nhiều người AC, nhưng lượng ăn subtask nhỏ nhỏ hơn.

Chúc mừng 8 bạn đã AC! Fun fact: 4/8 bạn giải được bài này là của THPT Chuyên Lương Thế Vinh.

turtle

• Author: Nguyễn Đinh Quang Minh
• Tester: Nguyễn Hoàng Hải Minh

BFS trạng thái

Subtask 1 có giới hạn \(N \le 10\), nên chỉ có \(10! = 3.628.800\) trạng thái, hơn nữa từ một trạng thái có thể đi được đến tối đa là \(N-1\) trạng thái khác. Vì vậy chỉ cần BFS để tìm đường đi ngắn nhất từ trạng thái hiện tại đến trạng thái đích.

\(N \le 20\)?

Mình thành thật xin lỗi các bạn đã bỏ công để nghĩ cách lấy 60% số điểm từ subtask 2, vì thực ra mình cũng không có cách giải nào (không phải thuật chuẩn) mà qua được subtask này cả :( . Có lẽ một thuật backtrack đặt cận tốt có thể ăn được một vài test của subtask này, nhưng mình không chắc chắn lắm.

pos[a[i]] = i

Thoạt nhìn, bước biến đổi hoán vị trong bài toán có vẻ khá phức tạp. Tuy nhiên, để ý kĩ bạn sẽ thấy, thực ra bước biến đổi bao gồm 2 thao tác:

1. Giảm các số có giá trị từ 2 đến \(K\) đi 1.
2. Gán số đang có giá trị 1 thành \(K\).

Fun fact: Khi viết đề, mình đã cố giải thích bước biến đổi theo kiểu chú rùa 1 sẽ hút độ rùa của \(K-1\) chú rùa còn lại nhưng cảm thấy hơi kì kì nên thôi ¯\_(ツ)_/¯

Chưa nhìn ra sự kì diệu của bài toán? Gợi ý: pos[a[i]] = i là một dòng vô cùng quan trọng trong code của mình.

Nếu bạn vẫn chưa nghĩ ra, hãy đọc tiếp phần bên dưới. Còn nếu nghĩ ra rồi thì cứ đọc tiếp để chắc chắn thuật toán của mình đúng.

Thuật toán O(N)

Nếu gọi \(pos[i]\) là vị trí của số \(i\) trong hoán vị, thì mảng \(pos\) cũng là một hoán vị. Vậy ta thử xem thao tác trong bài toán thay đổi mảng \(pos\) như thế nào?

1. Giảm các số có giá trị từ 2 đến \(K\) đi 1. Như vậy thì chính là gán \(pos[1] = pos[2], pos[2] = pos[3], ..., pos[K-1] = pos[K]\).
2. Gán số đang có giá trị 1 thành \(K\). Vậy là gán \(pos[K] = pos[1]\) (cũ).

Nói tóm lại, phép biến đổi này thay đổi hoán vị \(pos\) bằng cách chèn \(pos[1]\) vào bất kì vị trí \(K\) nào đó trong \(pos\). Ta muốn đưa hoán vị \(pos\) về hoán vị đơn vị (1, 2, ..., \(N\)). Điều đó cũng có nghĩa là ta chỉ đụng vào mỗi phần tử trong hoán vị không quá một lần, bởi vì ta chỉ cần đặt nó vào một vị trí \(K\) hợp lí nào đấy và không còn quan tâm đến nó nữa.

Vậy những số nào không cần đặt vào chỗ khác? Giả sử ta thực hiện thao tác \(x\) lần, tức là các số \(pos[x+1..N]\) không bị thay đổi. Điều đó chứng tỏ ban đầu \(pos[x+1] < pos[x+2] < ... < pos[N]\). Điều ngược lại cũng đúng: nếu \(pos[x+1] < pos[x+2] < ... < pos[N]\) thì ta có thể dừng thao tác ở lần thứ \(x\) bằng cách chèn các số \(pos[1..x]\) vào các vị trí hợp lý để nhận được hoán vị đơn vị. Như vậy, thuật toán của bài này thực ra rất đơn giản, tìm vị trí \(x\) nhỏ nhất sao cho \(pos[x+1] < pos[x+2] < ... < pos[N]\) rồi in ra \(x\).

Thống kê

In ra \(a[1] – 1\) được 45 điểm???

Trong lúc sinh test, mình gặp phải vấn đề sau: nếu sinh test random thì khả năng số \(N-1\) đứng sau số \(N\) (\(pos[N-1] > pos[N]\)) là rất lớn, vì vậy sẽ có chừng 50% số test đáp án là \(N-1\). Mặt khác, để đáp án là \(K\) thì \(pos[K+1] < pos[K+2] < ... < pos[N]\), do đó sinh random thì khả năng có đáp án bé gần như bằng không. Vậy mình đã giải quyết như nào?

Mình quyết định sinh test bằng cách: sinh trước vị trí của \(K+1, K+2, ..., N\) rồi sinh random các số còn lại (tất nhiên còn thêm vài test tay nữa). Nhưng một vấn đề khác lại nảy sinh: nếu \(K\) quá nhỏ so với \(N\) (giả sử, \(K = 100\) và \(N = 500000\)), thì khả năng \(a[1] = K+1\) là vô cùng lớn (\(= 1 – K/N\)). Cách cuối cùng để giải quyết vấn đề là thêm phần truy vết các thao tác. Tuy nhiên vào phút chót, mình quyết định không làm phức tạp thêm bài toán nữa vì mình cho rằng thời gian 3.5 tiếng là khá ít, cần phải khuyến khích những người nghĩ ra đáp án hơn là đánh đố họ. Dù sao thì việc in \(a[1] – 1\) được nhiều điểm hơn cả subtask 1 cũng làm mình khá buồn :(

Trong năm vừa rồi có kha khá nhiều bạn hỏi mình cũng như các bạn khác trong BTC HSGSO 2016 (môn Tin) về solution của contest. Vì hồi đó không có thời gian (thực ra là lười) nên bọn mình chưa có dịp chữa bài. Lần này mình quyết định làm cho chót.

Đề bài

Các bạn có thể tải đề bài gốc tại đây.

Lời giải

Mục lục

1. color
2. domino
3. gift
4. letter-o
5. paren
6. polylines
7. socket
8. zigzag

color

Author: Nguyễn Đinh Quang Minh

Ăn điểm

Để có 10% đầu tiên cho bài này ta nhận thấy chỉ có cách tô duy nhất là so le với \(K = 2\), như vậy chỉ cần in \(0\) khi \(K = 1\) và \(2\) khi \(K = 2 \) là bạn đã cầm trong tay 1 điểm đầu tiên.

Biểu diễn trạng thái

Ta sẽ tiếp cận bài toán, đầu tiên bằng phương pháp quy hoạch động. Qhđ thường là hướng giải đúng đối với những bài toán đếm. Để có thể triển khai qhđ, ta cần biết cách biểu diễn một trạng thái đang xây.

Để ý giới hạn của bảng là \(3 \times N\). Vì chỉ có 3 ô nên ta hoàn toàn có thể biểu diễn trạng thái của một cột bằng một \(K-\)mask – một số có 3 chữ số trong đó các chữ số trong khoảng \(0\) đến \(K – 1\) (theo cơ số \(K\)). 2 chữ số liên tiếp phải khác nhau, nên số trạng thái thỏa mãn một cột sẽ là \(5 \times 4 \times 4 = 80\) trạng thái với \(K = 5\).

Ta có thể có hàm quy hoạch động đơn giản \(f[i][mask]\) là số cách điền \(i\) cột đầu tiên, trong đó cột cuối cùng có trạng thái là \(mask\). Từ \(f[i][mask]\) ta chuyển trạng thái sang \(f[i + 1][mask']\), for hết \(mask'\) thỏa mãn. Ta có thể thấy cách này có độ phức tạp \(O(80^2 N)\), chưa đủ thỏa mãn cả subtask 2. Kể cả khi ta chỉ lọc ra các \(mask'\) thỏa mãn và for chúng, ta vẫn có độ phức tạp \(O(3380 N)\), vẫn chưa thể thỏa mãn subtask 2.

Cải tiến quy hoạch động

Thay vì chuyển trạng thái cả cột cùng lúc, ta có thể thay bằng việc mỗi lần chỉ điền 1 ô, lần lượt từ cột đầu sang cột cuối, mỗi cột điền từ trên xuống dưới. Trạng thái ta lưu lại sẽ là trạng thái của \(K\) ô cuối cùng ta điền.

Tại sao lại lưu như vậy? Thực chất, khi điền lần lượt, ta chỉ cần quan tâm đến ô phía trên và bên trái nó, tức ô cách ô hiện tại \(1\) và \(K\) bước điền. Nhưng do ta cần tính cả các ô phía sau nên ta phải lưu trạng thái của cả \(K\) ô trước đó.

Gọi \(f[i][j][mask]\) là số cách điền các ô từ đầu đến \((i, j)\), với \(K\) cuối cùng mình điền được lưu trong \(mask\). Để chuyển sang ô tiếp theo, ta cần for một trong \(K\) màu của ô tiếp theo ô \((i, j)\). Như vậy đpt sẽ là \(O(100 * N * K * 3)\) (\(5^2 \times 4\) trạng thái, do khi lưu như này có thể tồn tại 2 ô liên tiếp cùng màu), vừa khít qua subtask 2. Code hơi trâu nhưng không sao, worth it, vì ta đã có 50% số điểm.

Bạn có thể xem thêm 1 bài mình đã chữa có cách qhđ tương tự ở đây (bài Domino).

Nhân ma trận

Đối với những bạn đã biết về nhân ma trận, ta có thể bỏ qua phần quy hoạch động cải tiến phía trên và thay vào đó, cải tiến qhđ \(O(80^2 N)\) thành nhân ma trận \(O(80^3 \log N)\). Việc chuyển đổi không khó, thực chất ta chỉ cần dựng bảng chuyển đổi \(80 \times 80\) xem 2 trạng thái nào có thể chuyển được cho nhau, mũ \(N-1\) lần lên rồi lấy ma trận \(1 \times 80\) toàn 1 (thể hiện hàng đầu) nhân cùng tích ban nãy, ra được một ma trận \(1 \times 80\) mới, đáp số chính là tổng các phần tử.

Việc nhân ma trận như nào chỉ là kĩ thuật cơ bản nên mình sẽ không nói nhiều.

Kiến thức nhân ma trận, so với tối ưu quy hoạch động như trên, là phổ thông hơn nhiều, vì thế subtask 3 không cho nhiều điểm như subtask 2.

1 tỉ màu??

Đọc đến subtask 4 hẳn tất cả sẽ ngạc nhiên khi \(K\) thay đổi đáng ngạc nhiên: từ \(\le 5\) và là mấu chốt giải bài toán, thành \(10^9\) – không còn đưa được vào độ phức tạp nữa. Để đào sâu vào subtask này, ta cần có một nhận xét về tương quan các màu giữa các cột.

Tương quan các màu

Trong một cột, chỉ có 2 loại tương quan sau: – \(a,b,c\) – tức 3 ô trong cột khác nhau – \(a,b,a\) – tức 2 ô đầu và cuối giống nhau

Hơn nữa, số cách chọn màu cho cột \(i + 1\) chỉ phụ thuộc vào tương quan của hàng \(i\), theo bảng sau: – Từ \(a, b, c\): – Sang \(a, b, c\): có \((K-1)+2(K-2)^2+ (K-3)(K-1)+(K-3)(K-2)^2\) cách. – Sang \(a, b, a\): có \((K-1)+(K-3)(K-2)\) cách. – Từ \(a, b, a\): – Sang \(a, b, c\): có \((K-1)+(K-3)(K-2)\) cách. – Sang \(a, b, a\): có \((K-1)+(K-2)^2\) cách.

Việc chứng minh chỉ là công thức tổ hợp, mình sẽ không chứng minh để chống dài dòng.

Như vậy ta không cần lưu cụ thể các màu, mà chỉ cần tương quan giữa các màu, tức chỉ còn 2 trạng thái để quản lí chứ không nhiều như trưóc. Việc qhđ để ăn sub 4 (độ phức tạp \(O(2^2 N)\)) hay nhân ma trận để ăn sub 5 (độ phức tạp \(O(2^3 \log N)\)) có thể được thực hiện đơn giản.

domino

Author: thầy Hồ Đắc Phương

Backtrack

Ở subtask 1, đơn giản ta chỉ cần backtrack tất cả các cách đặt domino. Do bảng chỉ có \(2 \times 20\) nên không có đến \(2^{20}\) cách đặt là tối đa. Độ phức tạp sẽ là \(O(2^N)\).

Bổ đề: lát gạch cơ bản

Đếm số cách lát gạch vào bảng \(2 \times N\)

Có lẽ đây là bài toán nổi tiếng trong giới VNOI. Cách giải khá đơn giản: quy hoạch động \(f[i]\) là số cách lát \(i\) cột đầu tiên. Ta có 2 cách lát: 1 viên dọc (chuyển xuống \(f[i – 1]\)) hoặc 2 viên ngang (chuyển xuống \(f[i – 2]\)). Độ phức tạp là \(O(N)\), hoặc vì đây là phương trình đệ quy tuyến tính nên ta có thể nhân ma trận \(O(2^3 \log N)\).

Không khó để nhận ra \(f[i]\) cũng chính là số fibonacci, ta cũng có 1 số cách tính chính xác khác trong \(O(\log N)\).

Cách điền duy nhất?

Để giải tất cả subtask sau, ta cần có chút quan sát về các ô cấm: – Nếu một cột bị cấm cả 2 ô, hiển nhiên ta có bên trái và bên phải là 2 bài toán riêng biệt, ta chỉ cần tính riêng 2 bên rồi nhân vào nhau. – Nếu một cột bị chặn 1 ô, hiển nhiên ô đó thuộc một viên domino ngang. Ta sẽ phải lựa chọn viên ngang đó nằm lệch về bên trái hay bên phải.

Ngạc nhiên thay, cách chọn ô đó là duy nhất. Để hiểu rõ tại sao, hãy xét 3 trường hợp sau:

Nhận 1 bên

Hiển nhiên trong trường hợp này, số cách điền là 0. Đơn là vì có lẻ ô.

Nhận 2 bên, điền được

Xét cột thứ nhất, ta có cách điền domino duy nhất. Con domino này chắn 1 ô của cột thứ hai, làm cho bài toán đệ quy xuống. Tại mỗi bước chỉ có một cách điền duy nhất nên với cả đoạn cũng chỉ tồn tại 1 cách điền.

Nhận 2 bên, không điền được

Giống như trường hợp trên, nhưng vì khi đặt con domino cuối cùng, ta bị đặt trùng lên ô cấm, nên ta không thể điền trường hợp này.

Phân biệt với TH 2 như nào? Ta điền được khi và chỉ khi:

• Cả đoạn độ dài chẵn và 2 ô cấm cùng hàng, hoặc
• Cả đoạn độ dài lẻ và 2 ô cấm khác hàng

Cách tính

Xét một đoạn bị chắn 2 đầu là cột 2 ô cấm (hoặc biên, ta có thể coi 2 biên là 2 cột 2 ô cấm). Gọi \(P_1, P_2, ..., P_K\) là vị trí các cột có 1 ô cấm, từ trái sang phải.

Hiển nhiên nếu \(K\) lẻ thì có 0 cách điền vì có lẻ ô.

Ta có: – Xét đoạn \(1..P_1\): Hiển nhiên viên ở \(P_1\) sẽ đặt sang phải vì nếu không ta sẽ có TH 1. Số cách điền đoạn \(1..P_1-1\) là \(f[P_1 – 1]\). – Xét đoạn \(P_1..P_2\): Vì viên ở \(P_1\) đặt trọn trong đoạn nên \(P_2\) cũng vậy, nếu không sẽ bị TH 1. Số cách điền là 0 hoặc 1 phụ thuộc vào nó là TH 2 hay 3. – Xét đoạn \(P_2..P_3\), vì viên ở \(P_2\) nằm trọn bên trái nên trường hợp này như đoạn \(1..P_1\), số cách chọn là \(f[P_3 – P_2 – 1]\). – Vân vân, xét đến khi ta gặp \(P_{2k}..N\) thì cũng như đoạn đầu, số cách là \(f[N – 2k]\).

Số cách điền cả đoạn sẽ là tích số cách điền từng đoạn con.

Độ phức tạp là \(O(N \log 10^9)\), vì ta tính \(f[i]\) trong \(O(\log i)\).

Tại sao lại chia subtask như vậy?

Với \(K = 4\), bạn có thể mập mờ nhìn ra tính chất trên khi chia tất cả trường hợp 4 ô cấm. Bọn mình muốn hướng suy nghĩ phải theo mạch tự nhiên, không bị gò bó.

gift

Author: Nguyễn Đức Duy

Thuật toán backtrack

Với \(N \le 10\), ta có thể thực hiện backtrack, mỗi bước cho phần tử \(i\) cho Alice, Bob hoặc giữ lại. Đến cuối, nếu có đáp án, ta in ra và thoát chương trình.

Do mỗi bước ta có 3 lựa chọn nên độ phức tạp là \(O(3^N)\).

22 phần tử

Với \(N\) lớn hơn, hẳn là lượng tập con càng lớn so với giới hạn, vì thể xác suất tồn tại đáp số càng lớn. Ta sẽ chứng minh chỉ với 22 phần tử, luôn luôn tồn tại đáp số.

Hiển nhiên, với 22 phần tử, ta có \(2^{22} – 1\) tập con không rỗng. Đồng thời, các tổng nằm trong khoảng \(1.. 22 \times 10^5\). Vì \(2^22 – 1 > 22 \times 10^5\) nên theo định lí Dirichlet ta luôn có 2 tập có cùng tổng.

Gọi 2 tập này là \(x\) và \(y\). Chắc chắn 2 tập này không phải tập con của nhau, vì mỗi phần tử đều lớn hơn 0. Như vậy chắc chắn tồn tại ít nhất 1 phần tử của mỗi tập mà không tồn tại trong tập kia.

Ta loại đi các phần tử có trong cả 2 (vì chúng cùng trừ cả 2 bên đi 1 lượng), và còn lại 2 tập không rỗng. Đây chính là đáp số.

Như vậy, với \(N \ge 22\), ta chỉ cần bốc ra 22 phần tử rồi tính tất cả tổng tập con, lấy 2 tập bằng nhau và loại đi các phần tử trùng là sẽ ra đáp số.

Độ phức tạp là \(O(2^{22})\).

\(N\) “ất ơ”

Vậy với \(10 < N < 22\) thì sao? Rất tiếc bọn mình không chuẩn bị được test mà giết được thuật ở trên. Tuy nhiên, ta vẫn có thể backtrack gặp nhau ở giữa, lần lượt backtrack \(3^{10}\) trường hợp ở đầu và \(3^{N – 10}\) trường hợp ở cuối, sau đó ghép 2 số có hiệu trái dấu. Như vậy độ phức tạp sẽ không quá \(O(3^{N / 2})\).

letter-o

Author: mình

Lưu ý đây là bài output-only, vì vậy bạn có 5 tiếng để chạy chứ không phải 1 giây.

Thuật toán \(O(N^4)\)

Thực ra thuật toán \(O(N^4)\) khá đơn giản, ta chỉ cần for 2 góc của hình chữ nhật và kiểm tra liệu 4 cạnh của chúng có chứa toàn cùng kí tự không. Để kiểm tra ta có thể tính trước mảng cộng dồn \(O(N^2)\).

Lấy thuật \(O(N^4)\) có thể chạy 1s đến input 5, và ăn 50% số điểm. Bài thật là dễ!

Thuật toán \(O(N^3)\)

Ta nhận thấy, nếu ta for trước 2 cạnh song song của hình chữ nhật, thì chỉ cần xét các vị trí mà có toàn kí tự x nào đó trong cả đoạn nằm giữa 2 cạnh. Ta sẽ chọn 2 điểm xa nhau nhất mà 2 điểm đó dọc 2 cạnh đều là các kí tự giống nhau.

11111
10021
10311
11111
10231
11111
10230
11111

Xét ví dụ trên, chọn 2 cột đầu cuối. Ta thấy chỉ có các hàng 1, 4, 6 và 8 có thể làm 2 cạnh ngang của hình chữ nhật. Ngoài ra, chỉ có 1, 4, 6 được nối với nhau. Ta chọn hình lớn nhất (1 – 6).

Việc lựa chọn có thể được thực hiện chỉ trong \(O(N)\) bằng một vòng for lưu max. Như vậy ta có thuật \(O(N^3)\) đủ ăn input 6.

Sức mạnh của input!

Đối với input 7 và 8, đáp số được đảm bảo là lớn, nên bạn có thể sử dụng chiến thuật chỉ bài output-only mới có: sử dụng mắt.

Với mỗi số ta có thể in ra vị trí của chúng (và để trống những vị trí khác). Việc nhìn bằng mắt cũng sẽ cho ta thấy một số hình lớn, chỉ việc thử vào đáp số.

Tìm kiếm pattern

Nếu nhìn kỹ, bạn có thể nhận ra input 9 có pattern khá dị, khi chỉ có một số hình chữ nhật. Bạn có thể nhìn tay và chỉ chạy các miền có hình chữ nhật thỏa mãn.

... hoặc không

Để giải input 10, bạn cần phải nhận ra quy tắc quan trọng nhất: bạn không bị giới hạn bởi thời gian chạy của máy chấm. Vì thế hãy nhập input 10 vào, đặt cận đáp số và chờ 15-20 phút cho máy chạy. Tính trên máy trường mình, chỉ mất 1h để chạy tất cả input với \(O(N^3)\) đặt cận đáp số! Bạn có 5 tiếng cơ mà, chạy trâu rồi làm bài khác... đó là chiến thuật của bài này.

paren

Author: thầy Hồ Đắc Phương & Phạm Tùng Dương.

Đệ quy

Thực chất đây chỉ là một bài tính toán có chút lằng nhằng. Phương thức tính toán như sau, xét đoạn ngoặc \(l..r\) là 1 cặp ngoặc:

• Tính tất cả các cặp ngoặc con \(l_1..r_1, ..., l_p..r_p\)
• Độ cao của \(l..r\) là max độ cao của các cặp ngoặc con, cộng 1
• Độ dài của \(l..r\) là tổng độ dài của các cặp ngoặc con, cộng \(p-1\) khoảng cách ở giữa, cộng 2 hoặc 4 tùy loại ngoặc của \(l..r\)
• Phần tô màu của \(l..r\) là:
  • Nếu viền ngoài cùng của \(l..r\) là đen: độ dài \(\times\) độ cao \(-\) diện tích các hình con
  • Nếu không thì là 0
  • Sau đó cộng thêm phần tô màu các hình con

Dựng cây

Để có thể dựng quan hệ cha – con và tính đệ quy trong \(O(N)\), ta sẽ cần dựng cây bằng stack. Cách dựng như sau:

• Duy trì 1 stack, lúc đầu stack rỗng
• Đi từ trái sang phải, giả sử kí tự ta có là \(S_x\):
  • Nếu \(S_x\) là mở ngoặc: Nếu stack không rỗng, thì cặp ngoặc \(x\) có cha là đỉnh stack. Push \(x\) vào stack.
  • Nếu \(x\) là đóng ngoặc: xóa đỉnh stack.

Tổng độ phức tạp là \(O(N)\).

polylines

Author: mình

Quy hoạch động trâu cơ bản

Để đơn giản ta coi điểm xuất phát là \(0\), đích là \(M + 1\).

Ta có công thức quy hoạch động: Gọi \(f[i]\) là số đường đi kết thúc ở \(i\). Ta có – \(f[0] = 1\) – \(f[i] = \sum\limits_{X_j \le X_i, Y_j \le Y_i, i \neq j}f[j]\) – Đáp số là \(f[M + 1]\) – 1.

Để có thứ tự qhđ ta chỉ cần sort các điểm theo cả 2 tọa độ tăng dần. Chỉ đơn giản vậy ta có thuật toán \(O(N^2)\).

Tăng tốc!

Nhìn vào điều kiện của \(j\) ở hàm qhđ, ta nhận thấy hoàn toàn có thể lấy nhanh tổng các \(f[j]\) bằng 1 cấu trúc dữ liệu nào đó.

Nhận thấy, khi sort các phần tử theo \(X\) rồi lấy các phần tử đứng trước, ta chỉ còn cần lọc điều kiện \(Y\) là đủ. Việc này ta hoàn toàn có thể sử dụng BIT để lấy nhanh, sort tọa độ BIT theo \(Y\) rồi get prefix, update điểm.

Độ phức tạp là \(O(N \log N)\).

socket

Author: Nguyễn Đức Duy

Tìm đáp án

Không khó để nhận ra nếu chỉ có thể xếp được \(K\) thiết bị, ta luôn lấy \(K\) thiết bị có độ yêu cầu cao nhất. Vì vậy ta có thể sort thiết bị theo yêu cầu giảm dần rồi chặt nhị phân, kiểm tra xem có thể đặt \(K\) thiết bị đầu tiên không.

Xếp ổ điện như nào?

Ta có thể coi hệ thống ổ điện như một cây, trong đó gốc nối với nguồn. Xét 2 ổ điện \(i\) và \(j\), trong đó \(i\) gần gốc hơn \(j\). Nếu \(A_i\) < \(A_j\), ta hoàn toàn có thể đổi chỗ \(i\) và \(j\) và đáp án không thể nhỏ hơn ban đầu. Vì thế, để xây cây từ gốc, ta đặt các ổ điện theo thứ tự \(A_i\) giảm dần.

Với nhận xét trên, ta coi như \(A_i\) đã được xếp giảm dần. Giờ ta BFS theo từng tầng, dễ dàng nhận thấy khi xét tầng \(x\): – Nếu tồn tại \(B_i = x\), lập tức phải đặt \(i\) vào tầng đó. Nếu không đặt được thì kiểm tra fail. – Mỗi lần ở tầng \(x\) ta thêm ổ \(j\) vào, thì bớt 1 chỗ ở tầng \(x\) và thêm \(A_j\) chỗ ở tầng \(x + 1\). Vì \(A_j\) dương nên sau khi thêm ta luôn có nhiều chỗ ở tầng \(x + 1\) cho các \(B_i > x\) hơn ở tầng \(x\). Vì vậy, – Nếu \(B_i > x\), ta nhường cho ổ điện nếu còn, nếu không ta sẽ xét sau.

Tóm tắt thuật toán

Ta chặt nhị phân \(K\), kiểm tra xem có thể xếp \(K\) thiết bị \(B[1..K]\) vào không.

Để kiểm tra: – Lúc đầu ở tầng 0 ta có 1 vị trí đặt (ổ điện) – Nếu có nhiều \(B[i] = x\) hơn số vị trí đặt, kiểm tra fail. Nếu không, đặt hết \(B[i] = x\). – Nếu còn chỗ ở tầng \(x\) và còn ổ điện, đặt ổ điện cho tầng \(x + 1\). – Nếu còn chỗ, coi như chúng của tầng \(x + 1\).

Độ phức tạp sẽ là \(O((N + M) \log M)\), do các bước kiểm tra chỉ là \(O(N + M)\).

zigzag

Trường hợp \(K = 1\)

Không khó để nhận thấy với 10 chữ số và điều kiện phải thăm mỗi số ít nhất 1 lần và không cần đúng thứ tự, ta sẽ cần sử dụng đến bitmask. Từ ngôi nhà nguồn, ta cần bfs đến các đỉnh, tìm đường đi ngắn nhất dựng ra đủ mask.

Trên đồ thị ta dựng ra các đỉnh \((i, j, mask)\), tức đứng ở ô \((i, j)\) và tập các số đã đi qua là \(mask\). Từ đỉnh \((i, j)\) ta đi đến các đỉnh lân cận, thêm mask của đỉnh đó vào nếu cần, mất 1 bước. Đáp số là khoảng cách đến đỉnh gần nhất có mask đầy đủ 10 bit.

Độ phức tạp là \(O(NM2^{10})\).

\(K\) lớn hơn

Với \(K\) lớn đến \(M \times N\), ta không thể chỉ đơn giản là chạy thuật toán trên \(K\) lần, vì như vậy là không thỏa mãn giới hạn bài toán.

Thay vào đó, ta cần một cách để có thể chạy tất cả các truy vấn một lúc.

Lật ngược yêu cầu

Đề bài yêu cầu từ một ngôi nhà, ta đến một ô bất kì, miễn là đủ mask trên đường đi. Ta sẽ lật ngược yêu cầu lại, cho phép xuất phát từ đỉnh bất kì, đi thoải mái, với điều kiện kết thúc ở nhà và đủ mask trên đường đi.

Vậy điểm khác biệt là gì? Với bài toán không quan trọng đích với mỗi nguồn, ta cần BFS với từng nguồn riêng biệt. Tuy nhiên, với bài toán không quan trọng nguồn, ta có thể thực hiện BFS song song nhiều nguồn, để tính khoảng cách từ nguồn gần nhất tới mỗi đỉnh, với độ phức tạp chỉ bằng 1 lần BFS.

Nói cách khác, thay vì ta xuất phát từ \((Xi, Yi, 0)\), ta xuất phát từ tất cả các đỉnh \((i, j, 0)\) và tìm đường từ đỉnh bất kì đến \((Xi, Yi, 1023)\). Để chạy song song, tưởng tượng có một nguồn ảo nối đến tất cả nguồn thật với trọng số 0. Như vậy, vì chỉ có 1 nguồn (ảo), nên độ phức tạp chỉ là \(O(NM2^{10})\).

Hôm nay có hai phần: bài thầy Hoàng và bài anh Khuê. Cả 2 đều cần một sự tay to nhất định.

Tóm tắt đề bài

select (thầy Hoàng)

Cho dãy $S$ gồm các kí tự d và x. 2 người lần lượt chơi, mỗi lượt bốc 1 kí tự, kí tự này phải đứng cạnh 1 vị trí đã bị chọn trước đó (trừ nước đầu tiên được chọn thoải mái). Khi trò chơi kết thúc, người đi trước thắng khi có nhiều d hơn hẳn người kia. Đếm số vị trí ban đầu mà người đi trước có thể chọn mà vẫn đảm bảo chiến thắng?

Giới hạn

\(1 \le |S| \le 1000\).

eureka (thầy Hoàng)

Cho một hệ thống cân đĩa được biểu diễn như sau:

• Nếu chỉ gồm -1: Đây là một vị trí đặt quả cân.
• Là một cái cân có dạng x y A B trong đó \(x\) và \(y\) lần lượt là độ dài cánh tay đòn bên trái và bên phải của cân; \(A\) và \(B\) là 2 hệ thống cân được treo vào bên trái và bên phải của cân.

Hình dưới biểu diễn hệ thống cân được biểu diễn bằng dãy 12 18 4 2 -1 -1 10 8 3 3 -1 -1 6 4 -1 -1:

Trọng lượng các quả cân đều phải là số nguyên dương.

Hãy tìm trọng lượng cho các quả cân của từng vị trí đặt sao cho tất cả các cân đều thăng bằng và tổng trọng lượng các quả cân phải đặt là nhỏ nhất. Giả sử cân không có trọng lượng.

In ra tổng nhỏ nhất lấy dư cho \(123456789\).

Giới hạn

Miêu tả được cho bởi dãy \(A[1..N]\).

\(1 \le N \le 3 \times 10^5\), \(A[i] = -1\) hoặc \(1 \le A[i] \le 100\).

liondance (thầy Hoàng)

Cho 2 dãy số \(A[1..N]\) và \(B[1..N]\). Tìm dãy con chung dài nhất sao cho 2 phần tử liên tiếp chênh lệch nhau không quá \(d\). Nếu có nhiều dãy, in ra dãy có thứ tự từ điển lớn nhất.

Giới hạn

\(1 \le N \le 4000\), \(1 \le A[i], B[i] \le 10^9\)

desert (thầy Hoàng)

Trên mặt phẳng cho \(N\) điểm. Tìm đường đi từ \(1\) đến \(N\) sao cho khoảng cách Manhattan lớn nhất giữa 2 điểm liên tiếp đi qua là nhỏ nhất.

Giới hạn

\(1 \le N \le 10^5\), tọa độ \(-10^9 \le X_i, Y_i\le 10^9\)

Trốn việc (anh Khuê)

Cho dãy số \(A[1..3N]\), chọn ra tập số có tổng lớn nhất sao cho trong \(N\) số liên tiếp bất kì có không quá \(K\) số được chọn.

Giới hạn

\(1 \le N \le 200\), \(1 \le K \le 10\), \(1 \le A[i] \le 10^6\)

Party1 (anh Khuê)

Cho \(N\) bạn nam và \(M\) bạn nữ, và \(K\) mối quan hệ nam – nữ. Liệt kê tất cả bạn nam và bạn nữ chắc chắn sẽ xuất hiện trong cặp ghép cực đại.

Giới hạn

\(1 \le N, M \le 10^4\), \(1 \le K \le 10^5\).

Party2 (anh Khuê)

Cho đồ thị \(N\) đỉnh \(M\) cạnh xanh \(K\) cạnh đỏ, đỉnh \(i\) có trọng số \(A[i]\). Chọn một tập điểm có tổng trọng số lớn nhất thỏa mãn: – 2 đỉnh có cạnh xanh nối giữa thì không được cùng chọn. – 2 đỉnh có cạnh đỏ nối giữa thì cùng được chọn, hoặc cùng không được chọn.

Đồng thời, đếm số cách chọn tối ưu.

Giới hạn

\(1 \le N \le 250\), \(0 \le M \le \frac{N(N-1)}{6}\), \(\frac{N(N-1)}{3} \le K \le \frac{N(N-1)}{2}\)

Lời giải

select

Chuyển đổi bài toán

Rất khó quản lí trạng thái thắng thua khi bài toán yêu cầu so sánh số lượng. Vì vậy, ta sẽ biến đổi bài toán một chút – mặc dù tính chất thắng – thua không thay đổi.

Thay vì so sánh số lượng d của từng người, ta lấy số lượng d của người đi trước trừ đi người đi sau. Hiển nhiên người đi trước muốn hiệu dương – tức đối đa hóa nó, và người đi sau muốn tối thiểu hóa nó.

Bởi vì đây là trò chơi hữu hạn bước, và 2 người đều phải chơi tối ưu, nên ta sẽ chỉ đi tìm một kết quả duy nhất: hiệu tối ưu của trò chơi, với mỗi cách chọn bước đầu.

Quy hoạch động

Gọi \(f[l][r]\) là hiệu tối ưu của trò chơi, nếu trò chơi bắt đầu với trạng thái đoạn \(l..r\) bị khuyết. Ta có: – Hiển nhiên \(f[l][r] = 0\) nếu \(l..r\) đã phủ toàn bộ vòng tròn. – Ta có thể hiểu độ dài \(l..r\) sẽ tương đương với số bước đã xảy ra, vì vậy ta có thể biết được lượt đi tiếp theo là của ai. – Nếu đây là lượt của người đi trước, hẳn hắn ta sẽ muốn \(f[l][r]\) lớn nhất có thể, tức hắn sẽ chọn vị trí \(l – 1\) hay \(r + 1\) sao cho \(f[l – 1][r]\) hoặc \(f[l][r + 1]\), cộng vị trí hắn chọn nếu nó màu đỏ, sao cho tổng ấy lớn nhất có thể. Nói cách khác ta có: \[ f[l][r] = \max(f[l – 1][r] + (\text{S[l – 1] == 'd'}), f[l][r + 1] + (\text{S[r + 1] == 'd'}))\] – Ngược lại, người đi sau sẽ muốn lựa chọn của mình là nhỏ nhất có thể, tức: \[ f[l][r] = \min(f[l – 1][r] - (\text{S[l – 1] == 'd'}), f[l][r + 1] - (\text{S[r + 1] == 'd'}))\] Lưu ý dấu -, bởi ta đang tối ưu hiệu người đi trước trừ người đi sau.

Ta có thể tính tất cả các hàm \(f[1][1]\), \(f[2][2]\), ..., \(f[N][N]\) trong độ phức tạp \(O(N^2)\).

Đếm vị trí tốt

Một vị trí \(i\) thỏa mãn đầu bài nếu như hiệu tối ưu lớn hơn \(0\), bởi khi đó người thứ nhất luôn có thể làm cho mình có nhiều d hơn. Như vậy, ta chỉ cần thử hết các vị trí \(i\) và kiểm tra xem \(f[i][i] > 0\) đúng không.

Tổng độ phức tạp của bài toán là \(O(N^2)\).

eureka

Tính chất của tổng trọng lượng

Xét một hệ thống cân, không khó để chứng minh tổng trọng lượng của nó phải là một bội của số \(X\) tương ứng với từng hệ thống.

Nhiệm vụ của ta là đi tìm \(X\) đó cho cả hệ thống lớn, bằng cách tính từ các hệ thống con.

Quy nạp

Hiển nhiên quả cân có thể nhận trọng lượng bất kì, vậy quả cân là hệ thống cân có \(X\) là 1.

Ta xét hệ thống cân \(a, b, X_l, X_r\) trong đó \(X_l, X_r\) là các giá trị mình đã tính trước đó cho hệ thống cân bên trái và phải. Ta có: – Tồn tại \((p, q) = 1\) sao cho \(paX_l = qbX_r\). Hiển nhiên đây là \(p\) và \(q\) có tổng nhỏ nhất thỏa mãn. – Khi đó, \(X = pX_l + qX_r\).

Ta có thể nhận thấy \(\frac{p}{q} = \frac{bX_r}{aX_l}\), vậy \(p = bX_r / d\) và \(q = aX_l / d\) với \(d = \gcd(aX_l, bX_r)\). Như vậy \(X = \dfrac{X_l X_r(a + b)}{d}\).

Số lớn

Ta nhận thấy từ công thức trên rằng đáp số có thể rất lớn. Ta không cần phải in số lớn, tuy vậy các phép tính như \(\gcd\) không thể được tính khi số đã bị mod.

Tuy nhiên ta cũng không cần phải cài số lớn: Mỗi lần ta nhân thêm một số \(a + b \le 200\), nên thay vì lưu số lớn ta sẽ lưu tập ước nguyên tố và số mũ. Khi đó, các phép nhân (cộng số mũ), chia (trừ số mũ), lấy \(\gcd\) (lấy min số mũ) trở nên đơn giản, với độ phức tạp \(O(A[i])\).

Ta có thuật toán đáp số với độ phức tạp \(O(N * A[i])\).

Cài đặt

Một cách cài đặt ngắn gọn là sử dụng đệ quy, vừa đọc vừa làm. Ta thực hiện lần lượt: – Đọc \(a\) và kiểm tra xem có phải quả cân không. Nếu có trả về 1. – Đọc \(b\). – Đệ quy giải bên trái \(Xl\). – Đệ quy giải bên phải \(Xr\). – Tính và trả về \(X\).

liondance

Quy hoạch động

Về cơ bản, đây chỉ là bài toán LCS có thêm điều kiện, vì vậy hướng suy nghĩ của ta tất nhiên là cải thiện thuật toán quy hoạch động LCS, vì độ phức tạp yêu cầu cũng tương đương.

Vậy làm sao để quản lí trạng thái vẫn là \([i][j]\) khi ta còn cần thông tin về 2 phần tử liên tiếp? Ta sẽ cần “gói” nhiều thông tin hơn vào trạng thái \((i, j)\).

Thêm thông tin!

Ta sẽ định nghĩa hàm quy hoạch động như sau: Gọi \(f[i][j]\) là dãy con chung dài nhất khi sử dụng đoạn \(A[i..N]\), đoạn \(B[i + 1..N]\) và \(B[j]\) là phần tử cuối cùng được thêm ở đầu đoạn (để đơn giản, ta không tính cặp \(B[j]\) – ?? vào đáp số, cũng như coi \( B[0]\) là phần tử có thể ghép với mọi thứ).

Tại sao lại định nghĩa như vậy?

Nhờ có việc đánh dấu \(B[j]\) là số được thêm vào cuối cùng, ta có thể quản lí giá trị có thể thêm vào tiếp theo. Khi có \(f[i][j]\), và \(A[i] = B[k]\) (\(k \ge j + 1\)), điều kiện duy nhất đẻ kiểm tra chỉ là \(|B[j] – B[k]| \le d\).

Tại sao lại từ cuối?

Để giúp cho việc truy vết thứ tự từ điển, sau này mình sẽ nói đến.

Ta có thể tính hàm quy hoạch động này như sau – \(f[i][j]\) có thể được tính từ các trạng thái:

• \(f[i + 1][j]\), hiển nhiên
• \(f[i + 1][k] + 1\), với \(k \ge j + 1\) và \(A[i] = B[k]\).

Độ phức tạp là \(O(N^3)\). Ta sẽ cần một chút quan sát để hạ độ phức tạp.

Nhảy xuống \(O(N^2)\)

Khi xét \(f[i][j]\), ta có thể thấy nếu \(k \le k'\) và \(A[i] = B[k] = B[k']\) thì \(f[i + 1][k] \ge f[i + 1][k']\). Chứng minh rất đơn giản: \(B[k + 1..N]\) dài hơn \(B[k' + 1..N]\), mà điều kiện ghép không đổi.

Vì vậy, thực chất ta chỉ cần tìm \(k\) nhỏ nhất thỏa mãn \(k \ge j + 1\) và \(A[i] = B[k]\) để cập nhật vào \(f[i][j]\). Việc này có thể thực hiện bằng việc đánh dấu khi for ngược \(i\) và \(j\), nên độ phức tạp chỉ còn \(O(N^2)\).

Thứ tự từ điển

Khi quy hoạch động \(f[i][j]\), ta sẽ lưu thêm \(nx[i][j]\) là chỉ số \(B[k]\) mà mình chọn làm kí tự tiếp theo. Do điều kiện của dãy đáp số là phụ thuộc vào giá trị chứ không phải chỉ số, ta sẽ phải thêm vào các điều kiện sau đây để đảm bảo lựa chọn chỉ số tiếp theo cho truy vết: – Hiển nhiên nếu \(f[i + 1][j] \neq f[i + 1][k]\) thì ta chọn cái nào lớn hơn, vì được dãy dài hơn. – Nếu bằng nhau, hiển nhiên trong \(B[nx[i + 1][j]]\) và \(B[k]\) cái nào lớn hơn ta chọn. – Nếu vẫn bằng nhau, ta nhận thấy chắc chắn \(nx[i + 1][j] \ge k\), do vậy từ \((i + 1, k)\) ta có nhiều lựa chọn hơn (và có tất cả lựa chọn của) \((i + 1, nx[i + 1][j])\), nên ta sẽ chọn \((i + 1, k)\).

Khi đã có mảng \(nx[i][j]\), việc truy vết trở thành đơn giản.

desert

Cây khung Manhattan

Bản chất của việc dựng đường đi sao cho cạnh \(\max\) là \(\min\) chính là dựng cây khung nhỏ nhất của đồ thị.

Từ việc chăm chỉ đọc wiki, ta cũng biết có thể dựng lên cây khung giữa các đỉnh theo khoảng cách Manhattan với độ phức tạp \(O(N \log N)\). Thực chất đây chỉ là bài yêu cầu implement thuật toán đó.

Dựng cây khung như nào?

Ta có thể chứng minh rằng, để dựng cây khung Manhattan, với mỗi điểm ta chỉ cần nối cạnh đến đỉnh gần nó nhất trong mỗi góc phần tám. Vậy tìm chúng như thế nào?

Tìm điểm gần nhất trong góc phần tám

Giả sử ta sẽ giải bài toán cho góc phần tám có \(X \le X_0\), \(Y \le Y_0\) và \(X – Y \le X_0 – Y_0\).

Ta sắp xếp các điểm theo thứ tự \(X_i – Y_i\) giảm dần, và thêm vào một IT có tọa độ được xếp theo \(X_i\) giá trị \(X_i + Y_i\) lấy \(\max\).

Với mỗi điểm, ta get trong IT giá trị \(X_j + Y_j\) lớn nhất với \(X_j \le X_i\), rồi cập nhật điểm đó vào IT. Điểm get ra sẽ là điểm gần nhất theo góc phần tám này.

Để hiểu tại sao sắp xếp như vậy lại đúng, xem hình dưới.

Dễ dàng làm với góc phần tám đối diện, chỉ cần for tập điểm ngược lại.

Giải nhanh tất cả các phần

Thay vì cài tất cả các trường hợp góc phần tám, ta có thể chỉ cần giải 2 góc đối diện như trên, rồi thực hiện phép quay 90 độ cho tất cả các điểm theo gốc, và tiếp tục giải.

Hiển nhiên sau khi xoay 3 lần ta sẽ giải đủ 8 góc phần tám.

Trốn việc

Liên tưởng

Trong một hệ thống \(N\) máy song song, ta phải đảm bảo trong khoảng thời gian \(M\) bất kì không có quá \(N\) thao tác được thực hiện trên bất cứ máy nào. Ta sẽ làm như nào?

Một cách đơn giản là ra lệnh cho một máy, sau khi thực hiện một thao tác, sẽ ngủ trong \(M\) giây. Như vậy, không có khoảng thời gian \(M\) nào có một máy chạy 2 lần, vì thế không có chuyện có nhiều hơn \(N\) thao tác được chạy.

Ta sẽ sử dụng ý tưởng này cho bài toán.

Biến đổi bài toán

Đề bài yêu cầu ta chọn một tập lớn nhất sao cho cứ \(N\) phần tử liên tiếp bất kì có không quá \(K\) phần tử được chọn. Ta sẽ biến bài toán thành: Cho phép chạy \(K\) máy lựa chọn song song, mỗi phần tử chỉ được cho một máy lựa chọn, trong khoảng \(N\) bất kì không có máy nào chọn liên tiếp 2 phần tử.

Nếu \(K = 1\), ta có thể sử dụng quy hoạch động \(f[i] = \max(f[i – 1], f[i – N] + A[i])\). Với \(K\) lớn hơn, ta sẽ phải tìm cách khác để đảm bảo mỗi phần tử chỉ được tối đa một máy lựa chọn.

Hãy tưởng tượng một đường ống \(3N + 1\) đoạn liên tiếp nối thành một đường thẳng. Ngoài ra đường ống thứ \(i\) còn được nối với \(\min( i + N, 3N + 1)\). Từ đỉnh 1 ta cho \(K\) robot chạy về hướng \(3N + 1\). Các robot có thể đi đường \(i\) – \(i + 1\) thoải mái, nhưng mỗi đường đi \(i\) – \(i + N\) chỉ có thể cho 1 robot đi qua, đồng thời sẽ thu về \(A[i]\) đồng tiền. Ta cần thu về nhiều tiền nhất có thể.

Nghe rất giống một bài luồng max cost.

Dựng luồng

Ta áp dụng toàn bộ ý tưởng của đường ống vào luồng.

• \(3N + 2\) đỉnh, \(0\) là nguồn \(3N + 1\) là đích.
• \(0\) => \(1\): cap = \(K\), cost = \(0\)
• Với \(i > 0\), \(i\) => \(i + 1\): cap = \(inf\), cost = \(0\)
• Với \(i > 0\), \(i\) => \(\min(i + N, 3N + 1)\): cap = \(1\), cost = \(A[i]\)

Trên mạng, ta tìm luồng max cost. Hiển nhiên luồng cực đại là \(K\), nhưng ta chỉ cần quan tâm đến cost tối đa. Cost chính là đáp số.

Độ phức tạp là O(luồng 600 đỉnh 1000 cạnh).

Party1

Thay đổi mục tiêu

Thay vì đi tìm những đỉnh mà xuất hiện trong mọi cặp ghép cực đại, ta sẽ tìm những đỉnh không có tính chất đó. Thật vậy, ta sẽ cần tìm những đỉnh mà khi bỏ nó đi, kích cỡ cặp ghép cực đại vẫn không thay đổi.

Tính chất của cặp ghép

Đầu tiên, ta dựng cặp ghép cực đại trên đồ thị đã cho. Hiển nhiên các đỉnh không thuộc cặp ghép là các đỉnh cần tìm. Ta sẽ chỉ xét đến các đỉnh thuộc cặp ghép.

Giả sử \(v_0\) là một đỉnh không được ghép. Xét đường tăng \(v_0, v_1,..., v_{2k}\). Hiển nhiên độ dài đường tăng phải chẵn, nếu không ta có thể tăng số cặp ghép, không thỏa mãn tính chất cặp ghép cực đại.

Ta nhận thấy, nếu xóa đi 1 trong các đỉnh \(v_2, v_4, ...,v_{2k}\), ta sẽ tách đường tăng hiện tại ra thành 1 đường tăng lẻ, đồng thời số cặp ghép giảm đi 1. Tuy nhiến, do tồn tại đường tăng lẻ nên ta có thể đảo lại, làm tăng số cặp ghép về như cũ. Vì vậy \(v_2, v_4, ..., v_{2k}\) đều là các đỉnh cần tìm.

Nếu một đỉnh \(x\) khi xóa đi không tạo ra đường tăng lẻ nào (nhưng làm giảm số cặp ghép), chắc chắn nó không phải đỉnh cần tìm.

Thuật toán

Trước tiên, tìm cặp ghép. Sau đó, ta BFS từ các đỉnh không được cặp ghép, đi theo các đường tăng, đánh dấu các đỉnh cùng phía được thăm.

Do tính chất của đồ thị 2 phía nên ta chỉ cần 2 lần BFS, mỗi lần xuất phát từ tất cả các đính không được thăm trên cùng 1 phía.

Độ phức tạp sẽ là \(O(K \sqrt{N + M})\) do cặp ghép.

Party2

Nén đồ thị

Với tập đỉnh đỏ, ta sẽ gộp tất cả các đỉnh liên thông lại thành một, cộng tất cả các trọng số lại. Bài toán trở thành tìm tập độc lập cực đại trên đồ thị cạnh xanh.

Đây là một bài NP-Hard, chưa thể giải với giới hạn \(N \le 250\).

Số lượng đỉnh

Một chi tiết quan trọng là số lượng cạnh đỏ rất lớn. Với \(N = 250\) và \(K = \frac{N(N-1)}{3}\), chỉ có tối đa \(46\) đỉnh đã gộp (bao gồm 205 đỉnh có clique và 45 đỉnh bậc 0).

Từ đây, ta có chút hi vọng với thuật backtrack.

Đặt cận!

Đây là danh sách cận cần thiết để hi vọng qua được đống test(?): – Sort các đỉnh theo bậc rồi backtrack dần – Xử lí nhanh các đỉnh bị cấm – Loại bỏ các trường hợp khi tổng các đỉnh còn lại không lớn hơn max hiện tại – Tính riêng các tplt rồi nhân với nhau

Tóm tắt đề bài

SEQUENCE

Cho dãy số A[1..N]. Mỗi lần xóa ta sẽ xóa tất cả các số mang một giá trị x nào đó. Hỏi dãy dài nhất có thể tạo ra được mà không tồn tại i < j < k thỏa mãn A[i] == A[k] && A[i] != A[j]?

Giới hạn

1 <= N <= 10^5, 1 <= A[i] <= 100

AVTOGAME

Cho xâu S. Mỗi bước ta có thể chọn một đoạn l < r sao cho S[l] == S[r] và xóa đoạn đó khỏi xâu. Hỏi xâu ngắn nhất và dài nhất có thể tạo được (mà không thể xóa được tiếp) là bao nhiêu?

Giới hạn

10 test, 1 <= |S| <= 100, 'a' <= S[i] <= 'p'

DISKGAME

Cho một đĩa gồm N tầng xoay, mỗi tầng có K nấc xoay như hình dưới.

Mỗi bước ta được xoay 1 tầng sang trái hoặc phải 1 nấc. Hỏi số bước nhỏ nhất để tạo ra 1 cột có các số bằng nhau là bao nhiêu?

Giới hạn

1 <= N, K <= 2000

Lời giải

SEQUENCE

Điều kiện của dãy số

Ta có thể thấy, 2 số x và y không được cùng tồn tại trong đáp án nếu số x bị “kẹp giữa” số y hoặc ngược lại. Ta cũng có thể dễ dàng chứng minh một dãy không tồn tại cặp x, y nào như vậy là một dãy thỏa mãn.

Ví dụ

1, 2, 1, 3, 1, 4 không thỏa mãn vì số 2 bị kẹp giữa 2 lần số 1.

Bài toán của ta trở thành đi tìm một dãy không có 2 số nào “kẹp” nhau.

Đầu và đuôi

Xét ví dụ ở trên, ta có thể thấy 2 bị kẹp giữa bởi 2 số 1 ở vị trí 1 và 3. Ta cũng có thể nói 2 bị kẹp giữa bởi 2 số 1 ở 1 và 5.

Giả sử x kẹp giữa y ở 2 vị trí a <= b, ta cũng có thể nói x kẹp ở 2 vị trí first[x] <= a và b <= last[x] (2 lần xuất hiện đầu và cuối của x). Như vậy điều kiện để x kẹp giữa y chỉ là tồn tại y nằm giữa 2 vị trí xa nhau nhất chứa x.

Đi xa hơn, ta có thể thấy xét trên trục 1 chiều, tồn tại cặp x, y kẹp nhau khi và chỉ khi 2 đoạn (first[x], last[x]) và (first[y], last[y]) giao nhau.

Quy hoạch động

Như vậy, ta chỉ cần tìm 1 tập số sao cho tập (first[x], last[x]) của các số không giao nhau. Đây là bài toán quy hoạch động cơ bản, có thể thực hiện quy hoạch động trong O(N + M) với M là số phần tử khác nhau.

Gọi f[i] là số đoạn thẳng nhiều nhất ta có thể chọn trong khoảng 1..i. Từ đây, ta có 2 lựa chọn: – Thêm khoảng không, cập nhật f[i] cho f[i + 1]. – Thêm một đoạn (i + 1..j). Ta duyệt tất cả các đoạn thẳng có đầu mút trái là i + 1 và cập nhật f[i] + 1 cho f[j].

Đáp số là f[N].

AVTOGAME

Có thể xóa 1 đoạn?

Hiển nhiên các đoạn ta xóa sẽ không giao nhau, nên chỉ có 2 khả năng xảy ra để xóa đoạn [a < b]: – Nếu S[a] == S[b] ta xóa cả đoạn trong 1 bước. – Chọn 1 vị trí a < k < b - 1, xóa đoạn a..k rồi xóa đoạn k+1..b.

Dựa vào nhận xét này, ta dễ dàng dựng nên mảng canErase[l][r] (có thể xóa đoạn l..r không?) trong O(N^3):

for (int l = 1; l <= N; ++l) {
  for (int r = l + 1; r <= N; ++r) {
    if (S[l] == S[r]) canErase[l][r] = 1;
    for (int k = l + 1; k + 1 < r; ++k) {
      canErase[l][r] = canErase[l][r] || (canErase[l][k] && canErase[k + 1][r]);
    }
  }
}

Chi phí xóa hết nhỏ nhất

Thay vì giải bài toán xâu ngắn nhất còn lại, ta sẽ thay đổi bài toán bằng cách cho phép một kiểu xóa nữa: xóa 1 kí tự với chi phí 1. Sau đó ta đi tìm chi phí nhỏ nhất để xóa cả dãy. Ta có thể thấy tính chất các bước xóa rời nhau không thay đổi.

Hiển nhiên chi phí sẽ bằng đáp án, vì ta không bao giờ xóa đơn lẻ 2 kí tự giống nhau.

Để giải được bài toán này, ta cải tiến thuật toán kiểm tra tính xóa được phía trên, thành chi phí nhỏ nhất để xóa đoạn l..r. Hiển nhiên cost[i][i] = 1 vì chỉ có 1 kí tự. Với đoạn l..r ta có 2 cách xóa: – Nếu S[l] == S[r] ta xóa cả đoạn với chi phí 0. – Chọn l <= k < r rồi xóa 2 đoạn l..k và k + 1..r với tổng chi phí cost[l][k] + cost[k + 1][r].

Đáp số là cost[1][N], độ phức tạp là O(N^3).

Các kí tự còn lại

Để giải được bài toán dãy còn lại dài nhất, ta cần phải thấy tính chất của dãy còn lại. Tính chất khá đơn giản: không tồn tại 2 kí tự giống nhau trong xâu. Như vậy, ta cần nhặt ra 1 tập kí tự khác nhau sao cho các phần ở giữa có thể xóa được.

Điều kiện chỉ có 16 kí tự khác nhau cho ta một gợi ý: sử dụng bitmask để quản lí các kí tự đã lấy.

Quy hoạch động

Gọi bool f[i][mask] là tính khả thi của việc chọn ra tập kí tự thỏa mãn mask trong đoạn 1..i và xóa hết các kí tự còn lại, trong đó kí tự cuối ta chọn chính là S[i]. Ta có 2 lựa chọn: – Chọn cả kí tự S[i - 1], với điều kiện S[i - 1] != S[i] và mask có S[i - 1]. Ta lùi về trạng thái f[i - 1][mask ^ S[i]]. – Chọn một vị trí j < i và lấy kí tự này là kí tự đứng ngay trước S[i]. Điều kiện là S[j] != S[i], mask có S[j] và j + 1..i - 1 xóa được. Ta lùi về trạng thái f[j][mask ^ S[i]].

Độ phức tạp sẽ là O(N^2 * 2^16), chưa thể thỏa mãn bài toán. Ta cần một chút cải tiến để xóa bớt N.

Nhảy, chọn và xóa

Ta sẽ chỉnh sửa hàm quy hoạch động một chút: xóa bỏ điều kiện S[i] là kí tự cuối cùng chọn. Thay vào đó, ta “nhảy” từng bước, chọn hoặc sử dụng duy nhất một phép xóa. Cụ thể, từ trạng thái f[i][mask], ta có: – S[i] là kí tự được chọn. Điều kiện là mask chứa S[i]. Lùi về f[i - 1][mask ^ S[i]]. – S[i] là kí tự cuối cùng bị xóa. Vậy ta cần một vị trí j < i sao cho S[i] == S[j], và lùi về f[j - 1][mask].

Thoáng qua, vẫn là O(N^2 * 2^16). Làm sao để cải tiến? Ta thấy, trong trường hợp 2, điều kiện duy nhất là S[j] == S[i], mà chỉ có 16 loại kí tự, vậy ta hoàn toàn có thể lưu lại tất cả các trường hợp f[j - 1][mask] với mỗi lọai S[j] khác nhau.

Gọi g[i][mask] là tổng kết tất cả các trường hợp f[j][mask] thỏa mãn S[j + 1] == i. Ta có thể vừa đi vừa cập nhật g[S[i + 1]][mask], đồng thời trong trường hợp 2 ta chỉ cần lấy giá trị của g[S[i]][mask] trong O(1).

Độ phức tạp giảm xuống còn O(N * 2^16), thỏa mãn bài toán.

DISKGAME

Chi phí xoay của 1 đĩa

Hãy phân tích chi phí xoay của 1 đĩa để có số n ở vị trí p. Hiển nhiên chi phí là min(|x - p|) với x là các vị trí xuất hiện của n trong đĩa.

Thực chất ta chỉ cần xét đến 2 vị trí gần nhất bên trái và bên phải của p. Ta tạm gọi là x và y (để đơn giản ta coi x <= p <= y). Chi phí sẽ là min(p - x, y - p). Dễ dàng nhận thấy p - x là hàm tăng 1 đơn vị, y - p là hàm giảm 1 đơn vị với x <= p <= y. min của 2 hàm này sẽ là “núi” góc 45 độ có chóp ở trung điểm của x và y (hoặc có chóp ngang nếu trung điểm không nguyên).

Nếu ta xét tất cả các cặp vị trí liên tiếp của số, thì chi phí sẽ là nhiều “ngọn núi” như vậy.

Ta có thể thấy chi phí là một hàm như hình dưới, cho dãy 1 2 3 1 2 3 5 1 5 với n = 1. Lưu ý đoạn 8, 9, 1 cũng là 1 “ngọn núi”, vì thực chất đĩa là hình tròn.

Ta có thể cắt hàm thành các đường chéo tăng và giảm 45 độ để đơn giản hóa việc tính toán chi phí cho tất cả các đĩa.

Tổng cộng 1 đĩa sẽ bị cắt thành 2K đường chéo.

Tính tổng chi phí cho mọi đĩa

Với mỗi vị trí p và một số n, ta cần tính tổng chi phí xoay với mọi đĩa trong O(1). Biết chúng là tổng các đường chéo, làm sao để tính nhanh?

Ta sẽ vận dụng tính chất chúng đều có dạng x + b hoặc -x + b và sử dụng đường quét để tính với mỗi n.

Ta thấy, khi có k đoạn x + b[i], chi phí là kx + sum(b[i]) với bước tăng là k. Vì vậy thực chất với mỗi vị trí ta chỉ cần biết số đoạn tăng và tổng phần hằng số của chúng. Ta hoàn toàn có thể làm điều này khi quét bằng cách xét 2 đầu mút đầu (thêm đoạn) và cuối (xóa đoạn) sau đó xử lí từ trái sang phải.

Điều tương tự cũng đúng với hàm giảm.

int b[N * K + 1]; // tất cả b[i] của các đường tăng
vector<int> add[K + 2], remove[K + 2]; // các mốc thêm xóa

void addSegment(int l, int r, int id) {
  // thêm đoạn [l..r] = x + b[id]
  add[l].push_back(id);
  remove[r + 1].push_back(id);
}

void scan() {
  int value = 0, cnt = 0;
  for (int i = 1; i <= K; ++i) {
    for (auto p: add[i]) {
      value += b[p] + i - 1; // giá trị của i trước đó
      ++cnt;
    }
    for (auto p: remove[i]) {
      value -= b[p] + i - 1;
      --cnt;
    }
    value += cnt;
    // value là tổng ở vị trí i
  }
}

Ta có thể thấy độ phức tạp với mỗi n là O(K + số đoạn của n). Vì thế tổng độ phức tạp là O(K^2 + NK), do có 2NK đoạn tất cả.

Lưu ý: Mình đã tóm tắt đề bài ở trên, ai không muốn bị spoil thì đừng kéo xuống lời giải vội.

Hôm nay có 5 bài của thầy Đông. Do mình không được nghe thầy chữa buổi chiều nên solution là của mình, mặc dù 99% là đúng nhưng không đảm bảo. Thực chất bài không phải là khó quá.

Tóm tắt đề bài

ACM

Có N đội, mỗi đội có 11 chỉ số A[i][1..11]. Chọn 3 đội sao cho sum[i = 1..11][max(A[x, y, z][i])] (tổng của max chỉ số từng loại của 3 đội) là lớn nhất.

Giới hạn

1 <= N <= 30000

DOMINO (Bài toán thứ nhất)

Cho một bảng M x N với K ô cấm. Điền 0 hoặc 1 vào các ô không bị cấm sao cho với ô (i, j): – Nếu i + j lẻ, thì ô (i, j) không nhỏ hơn các ô không bị cấm xung quanh. – Nếu i + j chẵn, thì (i, j) không lớn hơn các ô không bị cấm xung quanh.

Giới hạn

1 <= M, N <= 16

DOMINO (Bài toán thứ hai)

Lần này không có ô cấm. Điều kiện như bài toán thứ nhất.

Giới hạn

1 <= N <= 8, 1 <= M <= 10^6

GAMES

Cho một dãy bit N phần tử chưa xác định và M điều kiện có dạng xor của A[l..r] là 0 hay 1. Tìm vị trí x đầu tiên mà điều kiện x mâu thuẫn với các điều kiện trên.

Giới hạn

1 <= N <= 10^9, 1 <= M <= 10^5

HANOI

Cho thuật toán giải bài toán tháp Hà Nội:

def HanoiTower(height, From, Temp, To):
  if height == 1:
    # Move one from `From` to `To`
    return
  HanoiTower(height - 1, From, To, Temp)
  HanoiTower(1, From, Temp, To)
  HanoiTower(height - 1, Temp, From, To)

# Call the function
HanoiTower(N, 'A', 'B', 'C')

• Tìm trạng thái của 3 tháp sau P lần gọi hàm.
• Cho trạng thái của 3 tháp, tính số bước đã gọi hàm P, hoặc in -1 nếu không tồn tại trạng thái đó khi giải.

Giới hạn

1 <= N <= 100. Lưu ý P có thể là số lớn.

WG

Cho một xâu P và một tập xâu S[1..N]. Dựng xâu T như sau: – Đầu tiên chọn một xâu trong tập S[] và thêm vào T – Sau đó, tìm xâu S[i] bất kì thỏa mãn S[0] == T.back() rồi thêm S[i][1..] vào.

Hỏi xâu T ngắn nhất chứa dãy con không liên tiếp P là gì?

Giới hạn

1 <= |P| <= 250, 1 <= |S[i]| <= 10, 1 <= N <= 1000

Lời giải

ACM

Tóm tắt đề bài

Có N đội, mỗi đội có 11 chỉ số A[i][1..11]. Chọn 3 đội sao cho sum[i = 1..11][max(A[x, y, z][i])] (tổng của max chỉ số từng loại của 3 đội) là lớn nhất.

Giới hạn

1 <= N <= 30000

“Phức tạp hóa” bài toán

Rất khó để thực hiện việc chọn nếu mình sử dụng việc lấy max của từng chỉ số. Vì thế ta có thể thay đổi bài toán thành chọn 3 đội rồi mỗi chỉ số lấy của một đội. Ta có thể thấy khi có quản lí đơn giản hơn: chỉ cần mỗi đội một bitmask lựa chọn chỉ số.

Hiển nhiên khi đã xét tất cả trường hợp thì trường hợp tốt nhất luôn là lấy max.

Ghép bitmask

Giả sử ta đã chọn 3 đội i, j và k. Ta sẽ gán lần lượt 3 mask x, y, z cho 3 đội này. Các mask sẽ thỏa mãn: – Đôi một rời rạc (x & y == 0, y & z == 0, z & x == 0) – Ghép lại thì có đầy đủ (x | y | z == (1 << 11) - 1) – Tổng chỉ số tương ứng lớn nhất.

Ta có thể thấy, thực chất ta không cần quan tâm các đội được chọn là đội nào. Với mask x được chọn trước, ta chỉ cần tính xem trong các đội thì đội nào có tổng tương ứng mask x là lớn nhất. Việc 2 mask x và y bị chọn trùng đội không quan trọng: Ta có thể coi như khi đó có 1 người được chọn với mask 0.

Ta có thể tính trước max[x] với mask x trong O(N * 2^11).

Chọn 3 phần tử

Trước tiên, ta có thể thấy nếu chỉ chọn 2 phần tử, ta có thể for tất cả cặp mask, kiểm tra trong O((2^11)^2). Hiển nhiên do 2 mask đều chỉ có 11 bit nên khi or lại với nhau (ghép bộ) thì mask mới vẫn chỉ có 11 bit. Vậy để chọn 3 phần tử, ta có thể tiếp tục ghép cặp tập đã or với tập max[x].

int two[1 << 11];
int three[1 << 11];

for (int i = 0; i < (1 << 11); ++i) {
  for (int j = 0; j < (1 << 11); ++j) {
    if (!(i & j)) // không có phần tử trùng
      two[i | j] = max(two[i | j], max[i] + max[j]);
  }
}
for (int i = 0; i < (1 << 11); ++i) {
  for (int j = 0; j < (1 << 11); ++j) {
    if (!(i & j)) // không có phần tử trùng
      three[i | j] = max(three[i | j], two[i] + max[j]);
  }
}

Đáp số chính là three[(1 << 11) - 1]. Độ phức tạp sẽ là O((2 ^ 11) ^ 2).

DOMINO (Bài toán thứ nhất)

Tóm tắt đề bài

Cho một bảng M x N với K ô cấm. Điền 0 hoặc 1 vào các ô không bị cấm sao cho với ô (i, j): – Nếu i + j lẻ, thì ô (i, j) không nhỏ hơn các ô không bị cấm xung quanh. – Nếu i + j chẵn, thì (i, j) không lớn hơn các ô không bị cấm xung quanh.

Giới hạn

1 <= M, N <= 16

Quy hoạch động

Thực chất đây là một bài toán quy hoạch động bitmask cơ bản. Nhận xét rằng với mỗi ô ta chỉ cần để ý bit ô bên trái và bên trên nó để có thể xét điều kiện thỏa mãn.

Khi quy hoạch động ta đi từng ô theo từng cột, trên xuống dưới trái qua phải. Gọi f[i][j][mask] là số cách lát kể từ ô (i, j) đến cuối cùng, với mask là trạng thái N ô cuối cùng đã đến trước (i, j) (tức các ô (i - 1, j), (i - 1, j + 1), ..., (i, j - 1)). Xem hính dưới:

Hình thể hiện trạng thái khi đã đến ô (i, j). Ô màu xanh lá là các ô đã lát, ô màu vàng thể hiện mask đang bị quản lí bởi bit tương ứng trong mask, ô màu xanh dương thể hiện ô sắp điền, ô màu đỏ thể hiện các ô chưa lát.

Để chuyển trạng thái ta xác định bit của ô (i, j), nếu nó thỏa mãn điều kiện với ô trái và trên thì gọi đến trạng thái tiếp theo (f[i][j + 1][mask mới] hoặc f[i + 1][1][mask mới] nếu đó là ô cuối của cột).

Chuyển mask như nào?

Ta để ý trên hình, bit 3, kể từ ô tiếp theo, không cần biết đến nữa. Ta có thể xóa bit này và đẩy lên, cho bit của (i, j) vào cuối. Như vậy trạng thái của mình luôn có N bit.

Độ phức tạp là O(N * M * 2^N).

Cài đặt như nào?

Nên gọi đệ quy có nhớ.

int f[20][20][1 << 16];
bool visited[20][20][1 << 16];

int cal(int i, int j, int mask) {
  if (i > M) return 1; // trường hợp biên
  if (visited[i][j][mask]) // đã tính
    return f[i][j][mask];
  visited[i][j][mask] = 1;
  for (int ch = 0; ch < 2; ++ch) {
    if (/*kiểm tra điều kiện đặt bit ch ở (i, j)*/) {
      f[i][j][mask] += cal(i + (j == N), j % N + 1, (mask << 1) & ((1 << N) - 1) + ch);
    }
  }
  return f[i][j][mask];
}

// x & ((1 << N) - 1) để lấy x % (1 << N), N bit cuối của x.
// (x << 1) == x * 2, đẩy các bit sang phải 1 đơn vị.

int ans = cal(1, 1, 0);

DOMINO (Bài toán thứ hai)

Lần này không có ô cấm. Điều kiện như bài toán thứ nhất.

Giới hạn

1 <= N <= 8, 1 <= M <= 10^6

Nhân ma trận

Lần này không có ô cấm, nên với mỗi hàng ta chỉ cần quan tâm mask của nó là gì. Từ đây ta có thể nghĩ đến việc nhân ma trận.

Giới hạn N nhỏ, M lớn cũng mang đến cho ta gợi ý này.

Số trạng thái

O((2 ^ N)^3 * log(M)) chưa thể thỏa mãn bài toán. Ta phân tích thêm một chút: với mỗi cột, ta có thể loại ra các trạng thái không thỏa mãn các điều kiện giữa 2 ô liên tiếp trên cùng cột.

Việc thử nghiệm cho thấy với N = 8 cũng chỉ có 55 trạng thái, có thể nhân ma trận.

Điều kiện theo i + j

Khi chuyển từ cột 2i sang cột 2i + 1, điều kiện bị thay đổi: thứ tự các ô trong cột đang từ lẻ, chẵn, lẻ, ... thành chẵn, lẻ, chẵn,... Điều này làm cho việc chuyển trạng thái không thể thực hiện đơn thuần.

Ta có thể sửa điều này bằng cách thêm 1 bit cho trạng thái của cột, chỉ xem đây là trạng thái cho cột lẻ hay chẵn.

Bảng chuyển đổi của mình sẽ chỉ cho phép chuyển từ cột lẻ sang chẵn và ngược lại.

Để đơn giản từ giờ ta gọi số trạng thái là P (P <= 110).

Ma trận gốc và đáp số

Hiển nhiên ta trận gốc là một ma trận 1 x P, trong đó các ô thể hiện trạng thái cột lẻ sẽ là 1. Ta nhân ma trận gốc với bảng chuyển đổi đã lũy thừa M - 1, nhận được ma trận đáp số 1 x P. Đáp án chính là tổng các phần tử trong ma trận.

Độ phức tạp là O(P ^ 3 * log(M)).

GAMES

Tóm tắt đề bài

Cho một dãy bit N phần tử chưa xác định và M điều kiện có dạng xor của A[l..r] là 0 hay 1. Tìm vị trí x đầu tiên mà điều kiện x mâu thuẫn với các điều kiện trên.

Giới hạn

1 <= N <= 10^9, 1 <= M <= 10^5

Chặt nhị phân

Để tìm vị trí đầu tiên mâu thuẫn, ta chặt nhị phân x để tìm vị trí xa nhất mà vẫn tồn tại một dãy thỏa mãn các điều kiện từ 1 đến x.

Bài toán trở thành kiểm tra xem có một dãy tồn tại không.

Tính chất mảng dồn

Nếu ta xét mảng dồn S[1..N], thì điều kiện tổng xor l..r bằng 0 hay 1 tương đương với S[l - 1] với S[r] bằng nhau hay khác nhau.

Ngoài ra, S[i] có thể nhận được bất kí giá trị nào không phụ thuộc vào S[i - 1] nên ta có thể thoải mái gán một giá trị bất kì, nhưng chỉ một mà thôi.

Bài toán trở thành, liệu có thể gán dãy S[1..N] thỏa mãn các điều kiện các nhau không?

2 giá trị cho 1 biến

Ta có thể coi mảng S[] như một đồ thị N đỉnh. Gộp các đỉnh cùng giá trị, ta thấy việc gán giá trị 0-1 cho các đỉnh còn lại giống như tô màu 2 phía.

Như vậy, ta có thể kiểm tra xem đồ thị có phải 2 phía không.

Độ phức tạp sẽ là O(M + N).

Giảm số lượng đỉnh

Có tận 10^9 đỉnh, tuy nhiên chỉ có 10^5 cạnh. Vì thế chỉ có tối đa 2 * 10^5 đỉnh có bậc khác 0, ta chỉ cần quan tâm tới các đỉnh này.

Độ phức tạp chỉ còn O(M), mang lại thuật toán O(M * log(M)).

HANOI

Tóm tắt đề bài

Cho thuật toán giải bài toán tháp Hà Nội:

def HanoiTower(height, From, Temp, To):
  if height == 1:
    # Move one from `From` to `To`
    return
  HanoiTower(height - 1, From, To, Temp)
  HanoiTower(1, From, Temp, To)
  HanoiTower(height - 1, Temp, From, To)

# Call the function
HanoiTower(N, 'A', 'B', 'C')

• Tìm trạng thái của 3 tháp sau P lần gọi hàm.
• Cho trạng thái của 3 tháp, tính số bước đã gọi hàm P, hoặc in -1 nếu không tồn tại trạng thái đó khi giải.

Giới hạn

1 <= N <= 100. Lưu ý P có thể là số lớn.

Các bước của thuật toán

Ta có thể tóm tắt thuật toán trong 3 bước: – Chuyển tháp N - 1 từ A sang B dùng C làm đệm – Chuyển đĩa N từ A sang C – Chuyển tháp N - 1 từ B sang C dùng A làm đệm

Từ thuật toán, ta có thể xác định mình đang ở bước nào bằng cách xét vị trí của đĩa N. – Nếu N còn ở A thì ta ở bước 1. – Nếu không ta ở bước 2 hoặc 3.

Sau khi xác định được vị trí của N, ta có thể bỏ nó đi và đệ quy xuống bước dưới, coi như ta đang giải bài toán chuyển tháp N - 1.

Tìm trạng thái từ P

Ta biết để chuyển tháp x sẽ mất 2^x - 1 bước, nên khi xét vị trí đĩa N ta có thể xác định xem ta đang ở bước mấy của việc chuyển tháp N: – Nếu P < 2^x thì ta đang ở bước 1. – Nếu P = 2^x thì ta đang ở bước 2. – Nếu P > 2^x thì ta đang ở lượt P - 2^x của bước 3.

Tùy theo bước ta xác định vị trí của đĩa N rồi đệ quy xuống bước tương ứng. Độ phức tạp là O(N). Code khá giống bò trên BST.

Tìm P từ trạng thái

Việc tìm P không khác gì tìm trạng thái. Khi xét tháp N, ta kiểm tra xem mình ở bước nào tùy theo vị trí của đĩa N: – Nếu N ở A, thì ta ở bước 1. Đệ quy vào bước 1. – Nếu N ở C, ta ở bước 2 hoặc 3. Cộng P thêm 2^x (cho bước 1+2) rồi đệ quy vào 3.

Độ phức tạp cũng là O(N).

WG

Tóm tắt đề bài

Cho một xâu P và một tập xâu S[1..N]. Dựng xâu T như sau: – Đầu tiên chọn một xâu trong tập S[] và thêm vào T – Sau đó, tìm xâu S[i] bất kì thỏa mãn S[0] == T.back() rồi thêm S[i][1..] vào.

Hỏi xâu T ngắn nhất chứa dãy con không liên tiếp P là gì?

Giới hạn

1 <= |P| <= 250, 1 <= |S[i]| <= 10, 1 <= N <= 1000

Tham lam dựng xâu

Khi đã có xâu T có thể lấy ra được dãy con là prefix x của P, ta có thể xác định số lượng kí tự ghép thêm khi thêm xâu S[i] bằng cách đi từ trái sang phải, tham lam kí tự tiếp theo cần ghép.

Từ đó ta tính trước được mảng nx[i][j], khi thêm xâu i với j kí tự đã ghép thì trạng thái mới là bao nhiêu. Độ phức tạp sẽ là O(N * |P| * |S[i]|).

Quy hoạch động

Ta có thể quy hoạch động f[i][j] là độ dài xâu T ngắn nhất sao cho xâu cuối cùng là i và đã ghép được j kí tự đầu tiên của P. Ta chọn thêm một xâu S[k] mới và chuyển trạng thái sang f[k][nx[k][j]]. Điều kiện là S[i].back() == S[k][0] và nx[k][j] != j.

Độ phức tạp sẽ là O(N^2 * |P|), chưa thỏa mãn bài toán.

Kí tự cuối

Thực chất ta không cần lưu chiều i là xâu cuối cùng, vì ta chỉ cần quan tâm đến kí tự cuối cùng của T, nên thay vào đó ta có thể chỉ lưu i là kí tự cuối cùng.

Độ phức tạp giảm xuống còn O(26 * |P| * N), thỏa mãn bài toán.

Thầy Phương cho 3 bài của FARIO 2017. Bài 1 đã làm rồi, bài 3 là bài approximate nên mình chỉ chữa bài 2.

Pyramid Cake

Tóm tắt đề bài

Cho một chiếc hộp có đáy chữ nhật M x N, vị trí (i, j) có độ cao là H[i][j]. Ta dựng một chiếc bánh nhiều tần thỏa mãn: – Các tầng là các hình chữ nhật chứa đỉnh (1,1) – Tầng trên phải nằm bên trong mặt phẳng của tầng dưới – Không ô nào cao hơn vị trí tương ứng của hộp – Thể tích bánh là lớn nhất.

Giới hạn

1 <= N, M <= 1000, 1 <= H[i][j] <= 10^8

Lựa chọn tầng

Do mọi tầng đề chứa (1, 1), bản chất ta chỉ cần tọa độ của góc còn lại là có thể xác định được duy nhất tầng hiện tại.

Tại sao ta chỉ cần quan tâm số tầng mà không phải độ cao? Hiển nhiên, với tầng (i, j) ta biết độ cao của tầng đó (nếu tính cả các tầng dưới nó) sẽ là M[i][j] = min(H[i'][j']) với i' <= i, j' <= j.

Khi nén tầng như vậy, ta có thể coi như tầng sau luôn nhỏ hơn tầng dưới, làm cho tập trạng thái không có chu trình và ta có thể quy hoạch động được.

Gọi f[i][j] là diện tích lớn nhất của hình có tầng dưới cùng là (i, j). Hiển nhiên ta sẽ đặt tầng dưới cùng độ dày M[i][j]. Sau đó, ta chọn một tầng nhỏ hơn để qhđ:

int cur = M[i][j] * i * j; // Diện tích phần đáy
for (int k = 1; k <= i; ++k)
	for (int l = 1; l <= j; ++l)
		if (k != i || l != j)
			f[i][j] = max(f[i][j], cur + f[k][l] - M[i][j] * k * l);

Tại sao ta trừ đi M[i][j] * k * l? Bởi phần diện tích này đã được tính vào đáy của hình dưới cùng.

Đáp số sẽ là max(f[i][j]), độ phức tạp là O(N^4), chưa đủ để giải quyết bài toán.

Thử tất cả?

Ta có thể thấy, mỗi hình chữ nhật con đều nhỏ hơn đáy ban đầu ít nhất 1 hàng hoặc 1 cột. Vậy tại sao mình không chọn 1 trong 2 hình to nhất ((i, j - 1) và (i - 1, j)) để làm đáy tiếp theo?

Rất có thể mọi người sẽ nghĩ việc này không đúng vì có thể không điền đc thêm tầng nào – nhưng nếu ta nghĩ theo cách nhìn khác – ta thêm 0 tầng, thì lựa chọn vẫn hợp lí.

Có thể việc này không tối ưu không? Giả sử, lựa chọn (x, y) (x < i, y < j) là tối ưu. Hiển nhiên nó cũng sẽ tối ưu cho (i, j - 1). Vậy ta hoàn toàn có thể chọn (i, j - 1) và nó sẽ chứa cả (x, y), kết quả không đổi.

Cải thiện thuật toán

Ta rút việc chọn tất cả cặp thành chọn một trong hai hình chữ nhật con lớn nhất. Độ phức tạp giảm xuống còn O(N^2), thỏa mãn bài toán.