training — Zumi's Blog

2017/04/28 Training

Fri, 28 Apr 2017 18:00:00 +0000

#training #apio #vietnamese #thầyHoàng #anhKhuê

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

2017/04/21 Training

Sun, 23 Apr 2017 06:11:00 +0000

#training #apio #vietnamese #thầyNghĩa

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 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ả.

2017/04/20 Training

Fri, 21 Apr 2017 16:36:25 +0000

#training #apio #vietnamese #thầyĐông

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

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

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

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.

2017-04-19 Training

Wed, 19 Apr 2017 13:00:00 +0000

#training #apio #vietnamese #thầyPhương

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.

2017/04/15 Training

Sun, 16 Apr 2017 10:34:00 +0000

#training #apio #english #anhMinh

Warning: If you want to try solving the problems, skip reading everything but the statements! Also, for hints, read slowly from top to bottom of each problem.

I didn't attend the class directly, but did the problems while going on a bus to Ninh Binh. The problems were somewhat exciting to me.

A. Sorting

Statements

You are given a permutation $A[1\dots n]$, along with $Q$ queries, each of the form $l, r$ which you should sort the subarray $A[l..r]$ increasingly or decreasingly. After all the queries are processed, print the middle value $A[N / 2 + 1]$.

Contraints

$1 \le N \le 10^5$, $1 \le Q \le 10^5$, $N$ is odd.

One problem from the past

The statements reminds me of a past problem I did on Codeforces. I didn't remember the source, but in short you are given a Latin string with the same sorting queries, and then you have to return the whole string. It was feasible to solve the problem in $O(Q \times 26 \times log(N))$ time because of the limited alphabet size.

The main idea is, for each $l, r$ query, count the number of instances of each character in the range. Then we can re-assign the characters' positions, from the smallest to the largest. To efficiently do range-counting and range-assignments we can maintain 26 interval trees, with lazy update.

However, the problem I faced yesterday was different: the alphabet size is much bigger. Perhaps a different approach was needed. Or maybe not?

The alphabet size

From the previous problem, we know that the problem can be solved efficiently if the alphabet size was small. “Is there anyway to make the numbers pool smaller?” – that was the first question that came to my mind.

The above problem somewhat resembles radix sorting, so of course it can also be applied to numbers. However splitting digits is not eligible, as reordering still takes too much time. We need to transform numbers into something that's both small in size and easy to reassign, maybe not even caring about its original value.

The problem only asked for one element. What if, all we care about is the element itself?

Relative ordering

It turns out that we don't actually need to sort the elements. Not entirely.

Let's choose a pivot, $X$. We transform every number larger than $X$ to $1$, and the rest to $0$. Sorting becomes wrong now, but the order relative to $X$ isn't: If we sort $l, r$ increasingly, every number that's smaller than $X$ still stays on the left of those which are larger than $X$. Therefore, this masked ordering isn't entirely wrong, because the correct ordering have the same mask, and we can assume that the unlerlying original values are on the correct positions. Of course, we don't need to care about it.

Of course, since the numbers are binary now, performing the above algorithm becomes a breeze.

After all the sortings, we get the middle number's mask. It doesn't give us the answer immediately, but it does leave a hint: If the number is 1 then the answer is larger than $X$, and vice versa.

Binary Search

To effectively use the previous hint, we can perform binary search on the value of $A[N / 2 + 1]$, checking whether it's larger than the middle value, and shorten the range according to the answer. That is also the final missing piece to solve the problem, giving us an $O(log(N) \times Q \times log(N))$ algorithm.

B. Zigzag

Statements

You are given an array $A[1..N]$ of distinct numbers. There are also $Q$ queries, each of the form $x y$ that asks you to change the $x$-th number to $y$. It is guaranteed that after each query the array always contains dintinct numbers. After each query you have to return the largest alternating subsequence of the array.

Constraints

$1 \le N \le 10^6$, $1 \le A[i] \le 10^9$

Alternating Subsequence

The first thing to do is analyzing the longest alternating subsequence problem. It turns out that it is not as difficult as it sounds, in fact it can be greedily built from an array with distinct numbers.

One nice observation from the problem: If there exists such $i$ that $A[i – 1] \le A[i] \le A[i + 1]$, then there always exists an optimal subsequence without $A[i]$. Why? Since they're consecutive numbers, $A[i – 1]$ is always better than $A[i]$ as a “lower” number, and $A[i + 1]$ is always better than $A[i]$ as an “upper” numbber. Therefore, it is safe to just remove $A[i]$ from the array without losing the optimal sequence.

Now let's continuously remove such numbers from the array until there is no such one. Which means, for each $i$, it is either $A[i – 1] \le A[i] \land A[i] \ge A[i + 1]$ or $A[i – 1] \ge A[i] \land A[i] \le A[i + 1]$. Wait... Isn't $A[..]$ now already an alternating sequence? More than that, $A[..]$ is an optimal longest alternating subsequence of the original array.

Dive a little deeper, we will find out that each $A[i]$ can be a part of the new array if and only if has the same above atrribute on the original array. Unless it's the first or last number of the array, in such case it's always included.

Testing an element

With the above observations, we can deduce whether an element will appear in our optimal subsequence: – It's the first or last element, or – Either it's both smaller or both bigger than its neighboring elements.

Using these conditions we can check each element in $O(1)$. To answer the length of the optimal subsequence one only has to count how many elements satisfies the above conditions.

Processing queries

If we change one number, how is each element's satisfiability affected? It turns out, only 3 of them are affected at most: the element itself, and its neighboring elements.

It is now easy to process each query in $O(1)$: just change the element and re-check every affected elements.

That concludes our $O(N + M)$ algorithm.

training — Zumi's Blog

2017/04/28 Training

Tóm tắt đề bài

select (thầy Hoàng)

Giới hạn

eureka (thầy Hoàng)

Giới hạn

liondance (thầy Hoàng)

Giới hạn

desert (thầy Hoàng)

Giới hạn

Trốn việc (anh Khuê)

Giới hạn

Party1 (anh Khuê)

Giới hạn

Party2 (anh Khuê)

Giới hạn

Lời giải

select

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

Quy hoạch động

Đếm vị trí tốt

eureka

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

Quy nạp

Số lớn

Cài đặt

liondance

Quy hoạch động

Thêm thông tin!

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

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

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

Thứ tự từ điển

desert

Cây khung Manhattan

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

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

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

Trốn việc

Liên tưởng

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

Dựng luồng

Party1

Thay đổi mục tiêu

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

Thuật toán

Party2

Nén đồ thị

Số lượng đỉnh

Đặt cận!

2017/04/21 Training

Tóm tắt đề bài

SEQUENCE

Giới hạn

AVTOGAME

Giới hạn

DISKGAME

Giới hạn

Lời giải

SEQUENCE

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

Ví dụ

Đầu và đuôi

Quy hoạch động

AVTOGAME

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

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

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

Quy hoạch động

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

DISKGAME

Chi phí xoay của 1 đĩa

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

2017/04/20 Training

Tóm tắt đề bài

ACM

Giới hạn

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

Giới hạn

Điều kiện theo `i + j`

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

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