Google Code Jam 2018 - Round 3

Bộ đề bài

# Bài tập Điểm Thời gian: Giới hạn bộ nhớ
1 Google Code Jam 2018 - Fence Construction 35 1.0s 1G
2 Google Code Jam 2018 - Field Trip 14 1.0s 1G
3 Google Code Jam 2018 - Name-Preserving Network 100 1.0s 1G
4 Google Code Jam 2018 - Raise the Roof 26 1.0s 1G

1. Google Code Jam 2018 - Fence Construction

Điểm: 35 Thời gian: 1.0s Bộ nhớ: 1G Input: bàn phím Output: màn hình

Fence Construction

Bạn là nhân viên của Công ty Xây dựng Hàng rào và được giao xây dựng \(F\) hàng rào. Mỗi hàng rào chạy theo một đường thẳng từ điểm này đến điểm khác. Nói chính xác hơn, mỗi hàng rào là một đoạn thẳng nối hai điểm phân biệt trong mặt phẳng hai chiều. Các hàng rào không giao nhau, ngoại trừ trường hợp có thể gặp nhau tại đầu mút. Toàn bộ các hàng rào liên thông: với mọi cặp hàng rào \(f\)\(g\), tồn tại một dãy \(f=f_1,f_2,\ldots,f_k=g\) sao cho \(f_i\) có chung một đầu mút với \(f_{i+1}\).

Khi bạn bắt đầu công việc, chưa có hàng rào nào được xây. Việc thi công dùng một máy in 3D đặc biệt có khả năng "bắn" hàng rào. Chỉ có một thiết bị như vậy, nên các hàng rào được xây lần lượt từng chiếc. Máy in đủ nhỏ để có thể coi nó là một điểm trên mặt phẳng.

Để xây hàng rào \(f\), trước tiên bạn phải đặt máy in tại một điểm \(p\) trên mặt phẳng sao cho máy nhìn thấy toàn bộ \(f\) mà không bị các hàng rào đã xây trước đó che khuất. Nói chính xác hơn, \(p\) phải thỏa mãn:

  • \(p\) không nằm trên \(f\), kể cả tại đầu mút;
  • với mọi điểm \(q\) nằm trên \(f\) nhưng không phải đầu mút của \(f\), đoạn thẳng nối \(p\) với \(q\) không giao bất kỳ hàng rào nào đã xây.

Để đưa máy in tới vị trí cần thiết, bạn có thể di chuyển nó từ vị trí hiện tại theo một đường liên tục, không nhất thiết là đường thẳng, miễn là đường đi không giao bất kỳ hàng rào nào đã xây, kể cả tại đầu mút. Bạn được tự do chọn vị trí đặt máy trước khi xây hàng rào đầu tiên và sau khi xây hàng rào cuối cùng.

Quy trình này có nghĩa là bạn không nhất thiết có thể xây các hàng rào theo mọi thứ tự. Chẳng hạn, một thứ tự nào đó có thể nhốt máy in lại và khiến bạn không thể đưa nó tới vị trí cần thiết.

Giám đốc đã phác thảo một thứ tự tương đối cho \(K\) trong số các hàng rào (chưa hàng rào nào được xây), nhưng không suy nghĩ kỹ về tính khả thi. Để tránh làm giám đốc tức giận, bạn phải giữ thứ tự này, đồng thời chèn \(F-K\) hàng rào còn lại vào bất kỳ vị trí nào để hoàn thiện thứ tự.

Với các hạn chế trên, hãy tìm một thứ tự xây hàng rào. Đề bài bảo đảm có ít nhất một thứ tự hợp lệ.

Dữ liệu vào

Dòng đầu tiên chứa số lượng bộ test \(T\). Sau đó là \(T\) bộ test.

Mỗi bộ test bắt đầu bằng một dòng chứa hai số nguyên \(F\)\(K\): tổng số hàng rào và số hàng rào trong thứ tự chưa hoàn chỉnh của giám đốc. Tiếp theo là \(F\) dòng; dòng thứ \(i\) trong số đó (đánh số từ 1) chứa bốn số nguyên \(A_i\), \(B_i\), \(C_i\)\(D_i\), cho biết hàng rào thứ \(i\) là đoạn thẳng từ \((A_i,B_i)\) đến \((C_i,D_i)\). \(K\) hàng rào đầu tiên được cho trong input chính là \(K\) hàng rào trong thứ tự của giám đốc.

Dữ liệu ra

Với mỗi bộ test, in một dòng có dạng Case #x: y, trong đó x là số thứ tự bộ test (bắt đầu từ 1), còn y là một thứ tự gồm các số nguyên từ 1 đến \(F\), phân tách bằng dấu cách, biểu diễn một thứ tự hợp lệ để xây các hàng rào.

Ràng buộc

  • \(1 \le T \le 100\).
  • \(4 \le F \le 300\).
  • \(-10^5 \le A_i \le 10^5\) với mọi \(i\).
  • \(-10^5 \le B_i \le 10^5\) với mọi \(i\).
  • \(-10^5 \le C_i \le 10^5\) với mọi \(i\).
  • \(-10^5 \le D_i \le 10^5\) với mọi \(i\).
  • \((A_i,B_i) \ne (C_i,D_i)\) với mọi \(i\).
  • Nếu \(p\) là một điểm không phải đầu mút trên một hàng rào thì \(p\) không nằm trên bất kỳ hàng rào nào khác.
  • Các hàng rào đã cho liên thông theo định nghĩa trong đề bài.
  • Tồn tại ít nhất một thứ tự hàng rào thỏa mãn mọi hạn chế thi công trong đề bài.

Phân nhóm

  • Test Set 1 (Visible): \(1 \le K \le 2\).
  • Test Set 2 (Hidden): \(1 \le K < F\).

Điểm các phân nhóm

Mỗi Test Set tương ứng với một subtask trên LQDOJ. Bảng dưới đây giữ nguyên điểm chính thức của Google Code Jam và quy đổi tỷ lệ trên tổng điểm của bài.

Phân nhóm Điểm Google Code Jam Tỷ lệ điểm của bài
Test Set 1 12/35 34,29%
Test Set 2 23/35 65,71%

Ví dụ

Ví dụ 1

Input
3
6 2
0 0 7 7
15 -2 10 0
0 0 0 10
0 0 10 0
0 10 10 10
10 0 10 10
6 1
0 0 0 10
0 0 10 0
0 10 10 10
10 0 10 10
0 0 7 7
15 -2 10 0
11 4
-10 0 10 0
-10 0 0 10
10 0 0 10
0 2 0 5
0 2 10 0
10 0 0 5
15 3 18 3
15 3 15 9
18 3 15 9
15 3 16 5
0 10 15 3
Output
Case #1: 1 2 3 4 5 6
Case #2: 5 6 1 2 3 4
Case #3: 11 10 7 8 9 1 2 3 6 5 4
Giải thích

Output mẫu chỉ đưa ra một trong các thứ tự hợp lệ; phần giải thích đầy đủ nằm bên dưới.

Test mẫu cuối cùng sẽ không xuất hiện trong Test Set 1.

Trong Test mẫu #1, có thể xây các hàng rào theo đúng thứ tự được cho: 1, 2, 3, 4, 5, 6. Lưu ý rằng theo danh sách của giám đốc, hàng rào 1 phải xuất hiện trước hàng rào 2.

Trong Test mẫu #2, không thể xây các hàng rào theo thứ tự được cho! Một thứ tự khả dĩ là: 5, 6, 1, 2, 3, 4. Lưu ý rằng khi danh sách của giám đốc chỉ chứa một hàng rào, điều kiện về thứ tự tương đối luôn hiển nhiên được thỏa mãn.

Trong Test mẫu #3, có thể xây các hàng rào theo thứ tự: 11, 10, 7, 8, 9, 1, 2, 3, 6, 5, 4. Lưu ý rằng các hàng rào 1, 2, 3 và 4 phải được xây theo đúng thứ tự tương đối đó.

Các hình sau minh họa một cách hợp lệ để xây các hàng rào trong Test mẫu #1.

Nguồn

Google Code Jam 2018, Vòng 3, bài Fence Construction.

Nguồn chính thức trên Google Coding Competitions Archive, phát hành theo giấy phép Apache-2.0.

2. Google Code Jam 2018 - Field Trip

Điểm: 14 Thời gian: 1.0s Bộ nhớ: 1G Input: bàn phím Output: màn hình

\(N\) người của một trường tiểu học — một giáo viên và \(N-1\) học sinh — đang tham gia một chuyến dã ngoại. Họ khám phá một đồng cỏ là lưới hai chiều vô hạn gồm các ô vuông đơn vị. Mỗi người hiện đứng trong một ô; nhiều người có thể cùng đứng trong một ô.

Khi đến giờ về, giáo viên và tất cả học sinh phải tập trung trong cùng một ô. Đó có thể là ô nào cũng được vì xe buýt có thể đón họ ở bất cứ đâu. Các học sinh đã được dạy một thuật toán giúp việc tập trung dễ dàng hơn:

  • Giáo viên là người số \(1\), còn các học sinh được đánh số từ \(2\) đến \(N\).
  • Một hành động của một người là đi tới một trong \(8\) ô có chung ít nhất một cạnh hoặc một góc với ô hiện tại, hoặc chọn đứng yên trong ô hiện tại.
  • Khi tín hiệu kết thúc chuyến dã ngoại vang lên, giáo viên kiểm tra xem cả \(N\) người đã ở cùng một ô chưa. Nếu rồi thì không cần hành động thêm. Nếu chưa, giáo viên bắt đầu một lượt:
    1. Trước tiên, giáo viên thực hiện một hành động như mô tả trên. Giáo viên tự quyết định sẽ đi đâu, nếu có di chuyển.
    2. Sau đó từng học sinh thực hiện một hành động, bắt đầu từ học sinh \(2\) và lần lượt đến học sinh \(N\); học sinh thứ \(i\) chỉ hành động sau khi người thứ \(i-1\) đã hành động. Hành động của các em là tất định: học sinh thứ \(i\) phải chọn phương án làm nhỏ nhất khoảng cách giữa tâm ô của mình và tâm ô của người thứ \(i-1\). Lựa chọn này không bao giờ nhập nhằng; đúng một trong \(9\) phương án cho khoảng cách nhỏ nhất.
  • Khi lượt kết thúc, giáo viên lại kiểm tra xem mọi người đã ở cùng một ô chưa. Nếu chưa, một lượt khác bắt đầu, và cứ tiếp tục như vậy cho đến khi tất cả ở cùng một ô.

Nếu giáo viên lựa chọn sao cho số lượt là ít nhất, số lượt đó bằng bao nhiêu?

Dữ liệu vào

Dòng đầu tiên chứa số bộ test \(T\). Mỗi bộ test bắt đầu bằng một dòng chứa số nguyên \(N\), là số người trong chuyến dã ngoại. Tiếp theo là \(N\) dòng; dòng thứ \(i\) trong số đó mô tả người thứ \(i\) và chứa hai số nguyên \(R_i\), \(C_i\), lần lượt là chỉ số hàng và cột của ô người đó đứng lúc đầu.

Dữ liệu ra

Với mỗi bộ test, in một dòng theo định dạng Case #x: y, trong đó x là số thứ tự bộ test (bắt đầu từ \(1\)) và y là số lượt nhỏ nhất có thể cần dùng như mô tả trên.

Ràng buộc

  • \(1 \le T \le 100\).

Phân nhóm

Test Set 1 (Visible):

  • \(2 \le N \le 10\).
  • \(0 \le R_i \le 8\) với mọi \(i\).
  • \(0 \le C_i \le 8\) với mọi \(i\).

Test Set 2 (Hidden):

  • \(2 \le N \le 10^4\).
  • \(0 \le R_i \le 10^9\) với mọi \(i\).
  • \(0 \le C_i \le 10^9\) với mọi \(i\).

Điểm các phân nhóm

Mỗi Test Set tương ứng với một subtask trên LQDOJ. Bảng dưới đây giữ nguyên điểm chính thức của Google Code Jam và quy đổi tỷ lệ trên tổng điểm của bài.

Phân nhóm Điểm Google Code Jam Tỷ lệ điểm của bài
Test Set 1 4/14 28,57%
Test Set 2 10/14 71,43%

Ví dụ

Ví dụ 1

Input
5
3
3 2
0 2
0 0
3
2 2
2 2
2 2
9
1 1
0 0
0 1
0 2
1 0
1 2
2 0
2 1
2 2
2
8 0
0 8
4
1 0
1 3
2 2
0 2
Output
Case #1: 2
Case #2: 0
Case #3: 1
Case #4: 4
Case #5: 2
Giải thích

Trong Sample Case #1, giáo viên ở \((3,2)\), tức hàng \(3\), cột \(2\). Học sinh \(2\)\((0,2)\) và học sinh \(3\)\((0,0)\). Một chiến lược tối ưu của giáo viên như sau:

  • Lượt 1:
    • Giáo viên đi tới \((2,2)\).
    • Học sinh \(2\) đi tới \((1,2)\).
    • Học sinh \(3\) đi tới \((1,1)\).
  • Lượt 2:
    • Giáo viên đi tới \((1,2)\).
    • Học sinh \(2\) đứng yên tại \((1,2)\).
    • Học sinh \(3\) đi tới \((1,2)\). Bây giờ mọi người đã ở cùng một ô.

Trong Sample Case #2, giáo viên và hai học sinh bắt đầu ở cùng một ô nên không cần lượt nào.

Trong Sample Case #3, giáo viên có thể đứng yên và đến cuối lượt đầu tiên, tất cả học sinh sẽ đi tới ô của giáo viên.

Trong Sample Case #4, giáo viên nên đi chéo bốn lần để tới \((4,4)\).

Trong Sample Case #5, trước hết giáo viên nên đi tới \((1,1)\); khi đó các học sinh \(2\), \(3\)\(4\) đều sẽ đi tới \((1,2)\). Lưu ý rằng dù mọi học sinh lúc này đã ở cùng một ô, giáo viên vẫn chưa ở đó nên phải bắt đầu lượt khác. Trong lượt thứ hai, giáo viên có thể đi tới \((1,2)\) để nhập nhóm và các học sinh sẽ đứng yên.

Nguồn

Google Code Jam 2018, Vòng 3, bài Field Trip.

Nguồn chính thức trên Google Coding Competitions Archive, phát hành theo giấy phép Apache-2.0.

3. Google Code Jam 2018 - Name-Preserving Network

Điểm: 100 Thời gian: 1.0s Bộ nhớ: 1G Input: bàn phím Output: màn hình

Một liên danh nghiên cứu đang xây dựng một trung tâm dữ liệu mới. Trong trung tâm dữ liệu, một tập hợp các máy tính được thiết lập để cùng làm việc và liên lạc qua một mạng. Mạng chỉ có các liên kết trực tiếp hai chiều giữa các máy tính. Hai máy tính \(c_1\)\(c_2\) không có liên kết trực tiếp vẫn có thể liên lạc nếu tồn tại ít nhất một đường đi gồm các liên kết \(l_1,l_2,\ldots,l_k\), sao cho \(l_i\)\(l_{i+1}\) có chung một đầu mút, \(c_1\) là một đầu mút của \(l_1\), còn \(c_2\) là một đầu mút của \(l_k\). Giữa hai máy tính bất kỳ có nhiều nhất một liên kết trực tiếp.

Liên danh yêu cầu bạn nộp một thiết kế cho biết mạng có bao nhiêu máy tính và chúng được nối với nhau như thế nào. Mỗi thiết kế phải thỏa mãn tất cả các điều kiện sau:

  1. Mạng có từ \(L\) đến \(U\) máy tính, kể cả hai đầu mút.
  2. Mỗi máy tính là đầu mút của đúng 4 liên kết, nối nó với 4 máy tính phân biệt khác.
  3. Mọi cặp máy tính đều có thể liên lạc với nhau theo định nghĩa ở trên.
  4. Các máy tính phải có thể tự xác định duy nhất danh tính của mình ngay cả khi ID của chúng bị thay đổi ngẫu nhiên trong lúc hệ thống tắt.

Nói rõ hơn về điều kiện cuối: ban đầu, mỗi máy trong số \(N\) máy tính của một thiết kế được gán một số nguyên duy nhất từ 1 đến \(N\) làm ID. Tuy nhiên, sau một thời gian ngừng hoạt động, hệ thống có thể khởi động lại với các ID đã bị hoán vị: mỗi máy vẫn mang một số nguyên duy nhất từ 1 đến \(N\), nhưng không nhất thiết là ID ban đầu. Mạng phải khôi phục được các số định danh ban đầu mà không dùng bất kỳ thông tin nào ngoài các liên kết trực tiếp đang tồn tại.

Để đánh giá thiết kế, liên danh dùng một chương trình tự động. Chương trình nhận thiết kế của bạn, kiểm tra ba điều kiện đầu tiên, rồi gửi lại một bản sao của thiết kế với các thay đổi sau:

  • Các ID duy nhất được hoán vị ngẫu nhiên; mỗi ID mới có xác suất như nhau được gán cho bất kỳ máy tính nào.
  • Mỗi liên kết được viết với ID nhỏ hơn đứng trước, theo các ID mới.
  • Toàn bộ tập liên kết được sắp tăng dần theo đầu mút thứ nhất, và nếu bằng nhau thì theo đầu mút thứ hai nhỏ hơn, tức theo thứ tự từ điển.

Bạn phải xác định chính xác các ID đã bị thay đổi như thế nào. Một cách hình thức, chương trình tự động tạo một hoán vị bí mật ngẫu nhiên \(f\) của các số nguyên từ 1 đến \(N\), rồi gán các số ấy cho các máy tính trong một “bản sao trắng” của mạng, nơi mọi liên kết cũ đã bị xóa. Với mỗi liên kết giữa máy \(i\) và máy \(j\) trong thiết kế của bạn, chương trình thêm vào bản sao một liên kết giữa \(f(i)\)\(f(j)\). Sau đó, bạn phải tái tạo chính xác hoán vị \(f\) mà chương trình đã tạo. Nếu tồn tại một hoán vị khác \(f'\) cho cùng kết quả và bạn trả về \(f'\), liên danh sẽ không chấp nhận thiết kế: trong trường hợp đó, bạn không thể bảo đảm rằng các ID được khôi phục là ID ban đầu.

Với mọi \(N\) từ 10 đến 100, kể cả hai đầu mút, đề bảo đảm tồn tại ít nhất một mạng gồm \(N\) máy tính thỏa mãn mọi điều kiện trên và có tính chất rằng áp dụng hai hoán vị khác nhau \(f\)\(f'\) sẽ tạo ra hai tập liên kết khác nhau.

Dữ liệu vào

Chương trình nhận dữ liệu từ bộ chấm theo giao thức tương tác bên dưới.

Dữ liệu ra

Chương trình gửi thiết kế mạng và câu trả lời tới bộ chấm theo giao thức tương tác bên dưới.

Giao thức tương tác

Bài tương tác

Đây là bài tương tác, nên khái niệm dữ liệu vào và dữ liệu ra khác với bài Code Jam thông thường. Một tiến trình riêng vừa cung cấp thông tin vừa đánh giá câu trả lời của bạn. Mọi thông tin đi vào chương trình qua đầu vào chuẩn, và mọi nội dung cần gửi phải được viết ra đầu ra chuẩn. Nhiều ngôn ngữ mặc định lưu đệm đầu ra; vì vậy, hãy bảo đảm dữ liệu thật sự được gửi đi, chẳng hạn bằng cách flush, trước khi chương trình dừng để chờ phản hồi. Mọi nội dung viết ra đầu lỗi chuẩn sẽ bị bỏ qua; không nên ghi quá nhiều vào đó. Phần Công cụ kiểm thử ở cuối đề cung cấp công cụ chạy cục bộ. Phần phân tích bài Number Guessing cũng có lời giải mẫu cho một bài tương tác Code Jam trước đây bằng mọi ngôn ngữ được hỗ trợ.

Ban đầu, đọc một dòng chứa số nguyên \(T\), là số lượng bộ test. Sau đó xử lý lần lượt \(T\) bộ test.

Với mỗi bộ test, trước tiên đọc một dòng chứa hai số nguyên \(L\)\(U\), là khoảng giá trị cho phép, kể cả hai đầu mút, của số máy tính trong thiết kế mạng.

Tiếp theo, tạo một thiết kế có \(N\) máy tính và in \(2N+1\) dòng biểu diễn thiết kế đó. Dòng đầu chứa số nguyên \(N\). Mỗi dòng trong \(2N\) dòng còn lại chứa hai số nguyên \(A\)\(B\), biểu diễn một liên kết khác nhau giữa hai máy \(A\)\(B\), với \(A\ne B\). Nếu đã liệt kê liên kết A B, bạn không được liệt kê lại A B hoặc B A.

Sau khi đọc thiết kế, bộ chấm kiểm tra ba điều kiện đầu tiên trong đề. Nếu bất kỳ điều kiện nào không được thỏa mãn, bộ chấm gửi một dòng chỉ chứa -1, chấm dứt mọi liên lạc và chờ chương trình của bạn kết thúc. Nếu chương trình kết thúc bình thường và không vi phạm giới hạn khác, kết quả sẽ là Wrong Answer.

Nếu cả ba điều kiện đều được thỏa mãn, bộ chấm gửi \(2N+1\) dòng. Dòng đầu chứa số nguyên \(N\), đúng bằng \(N\) bạn đã gửi. Mỗi dòng trong \(2N\) dòng tiếp theo chứa hai số nguyên mô tả các liên kết của bản sao thiết kế, cùng định dạng với thiết kế bạn gửi. Bản sao được tạo theo cách đã mô tả ở trên; hoán vị \(f\) được chọn đều ngẫu nhiên trong tất cả các hoán vị có thể và độc lập với thiết kế mạng của bạn.

Để kết thúc bộ test, gửi cho bộ chấm một dòng gồm \(N\) số nguyên \(X_1,X_2,\ldots,X_N\). Với mọi \(i\), \(X_i\) có nghĩa là máy tính mà bạn đã gán số \(i\) được gán số \(X_i\) trong bản sao của bộ chấm; nói cách khác, \(X_i=f(i)\).

Nếu danh sách này không đúng với danh sách bộ chấm đã tạo, bạn sẽ nhận Wrong Answer. Nếu đây là bộ test cuối cùng, bộ chấm không gửi thêm gì. Nếu chưa phải bộ test cuối, bộ chấm gửi một dòng chỉ chứa -1 rồi ngừng liên lạc. Trong cả hai trường hợp, bộ chấm chờ chương trình kết thúc và chỉ gán Wrong Answer nếu chương trình kết thúc bình thường mà không vi phạm giới hạn tài nguyên nào khác. Khi nhận -1, chương trình nên kết thúc ngay.

Không gửi thêm thông tin cho bộ chấm sau khi giải xong tất cả các bộ test. Cụ thể, nếu chương trình tiếp tục in ra đầu ra chuẩn sau danh sách các \(X_i\) của bộ test cuối, bạn sẽ nhận Wrong Answer.

Bạn được phép dùng cùng một thiết kế mạng cho nhiều bộ test, miễn là thiết kế đó thỏa mãn mọi điều kiện của từng bộ test. Ngoài ra, seed sinh ngẫu nhiên của bộ chấm là cố định, nên nếu gửi cùng một dãy thiết kế gốc theo cùng thứ tự, bạn sẽ nhận lại cùng một dãy bản sao.

Ràng buộc

  • \(1\le T\le 30\).

Phân nhóm

  • Test Set 1 (hiển thị): \(L=10\)\(U=50\).
  • Test Set 2 (ẩn): \(10\le L\le 50\)\(L=U\).

Ví dụ

Ví dụ tương tác

Transcript
  t = readline_int()           // reads 2 into t
  limits = readline_int_list() // reads 6 50 into limits
  printline 6 to stdout        // using 6 computers. Contestant designs an
                               //   octahedral network
  printline 2 4 to stdout
  printline 1 2 to stdout      // you do not need to list edges in any
                               //   particular order
  printline 3 1 to stdout      // you do not need to give the endpoints of a
                               //   link in order
  printline 1 4 to stdout
  printline 1 5 to stdout
  printline 2 3 to stdout
  printline 2 6 to stdout
  printline 3 5 to stdout
  printline 3 6 to stdout
  printline 4 5 to stdout
  printline 4 6 to stdout
  printline 5 6 to stdout
  flush stdout                 // judge verifies that the network meets
                               //   conditions 1-3 above, and secretly picks
                               //   2 6 3 1 5 4 as the new permutation
  n = readline_int()           // reads 6 into n
  repeat 12 times:
    add readline_int_list() to edges  // reads 1 2, 1 4, 1 5, 1 6, 2 3, 2 5,
                                      //   2 6, 3 4, 3 5, 3 6, 4 5, 4 6, in
                                      //   that order
  printline 2 5 6 1 3 4        // note that this is consistent with what the
                               //   judge sent, but is not the permutation the
                               //   judge used
  flush stdout                 // judge decides that this is wrong
  limits = readline_int_list() // expects to read the next case but gets -1,
                               //   indicating a wrong answer
  exit                         // exits to avoid an ambiguous TLE error
Giải thích

Ví dụ dùng \(L\) nhỏ hơn dữ liệu thật để dễ minh họa. Hơn nữa, không có mạng đúng 6 máy tính nào mà hai hoán vị khác nhau luôn tạo ra hai tập liên kết khác nhau, nên chọn đúng 6 máy tính là một ý tưởng tồi ngay cả khi giới hạn của đề cho phép. Trong transcript, thí sinh gửi một mạng hình bát diện. Danh sách 2 5 6 1 3 4 phù hợp với mạng đã đổi tên mà bộ chấm gửi lại, nhưng không phải chính hoán vị bí mật 2 6 3 1 5 4, nên đáp án bị từ chối.

Công cụ kiểm thử

Bạn có thể dùng công cụ kiểm thử đi kèm để chạy cục bộ hoặc trên nền tảng chính thức. Khi chạy cục bộ, cần chạy công cụ song song với chương trình của bạn; có thể dùng interactive runner. Hãy đọc hướng dẫn trong phần bình luận của tệp đó và phần Bài tương tác trong FAQ.

Hướng dẫn riêng của công cụ cũng nằm trong các bình luận bên trong công cụ. Bạn nên bổ sung các bộ test của mình. Dù công cụ được thiết kế để mô phỏng hệ thống chấm, nó không phải hệ thống chấm thật và có thể hoạt động khác. Nếu chương trình vượt qua công cụ nhưng không vượt qua bộ chấm thật, hãy kiểm tra phần Coding trong FAQ để bảo đảm bạn dùng cùng trình biên dịch với hệ thống chính thức.

Tải công cụ kiểm thử

Nguồn

Google Code Jam 2018, Vòng 3, bài Name-Preserving Network.

Nguồn chính thức trên Google Coding Competitions Archive, phát hành theo giấy phép Apache-2.0.

4. Google Code Jam 2018 - Raise the Roof

Điểm: 26 Thời gian: 1.0s Bộ nhớ: 1G Input: bàn phím Output: màn hình

Raise the Roof

Các nhà nhân chủng học đã khám phá một điều bất ngờ về một xã hội Hy Lạp cổ đại gồm toàn những nhà hình học: họ yêu tiệc tùng chẳng kém gì toán học! Trên thực tế, qua nhiều năm họ liên tục tổ chức những bữa tiệc ngày càng lớn, nên phải nâng mái phòng khiêu vũ để giữ mức tiếng ồn ở ngưỡng chấp nhận được.

Ta biết rằng mái phòng khiêu vũ luôn được đỡ bởi đầu mút của đúng ba cột. Mỗi cột là một đoạn thẳng mảnh vô hạn, bắt đầu trên sàn và dựng vuông góc với sàn. Mỗi khi muốn nâng mái, họ bắt đầu bằng việc dỡ mái hiện tại. Sau đó, họ xây một cột mới tại một vị trí chưa có cột. Cuối cùng, họ đặt một mái mới lên đầu cột mới và hai cột được xây gần đây nhất trong số các cột đã tồn tại. Vì những lý do huyền bí, không bao giờ có ba chân cột thẳng hàng và cũng không bao giờ có bốn đầu cột đồng phẳng.

Mỗi mái là một đa giác lồi nằm trong mặt phẳng được xác định bởi ba đầu cột đỡ nó. Với mỗi cột \(c\) được xây trước ba cột đỡ mái, mái không giao \(c\) tại bất kỳ điểm nào và đủ rộng để che phủ không gian phía trên \(c\). Mái không chạm sàn. Các mái khác nhau không nhất thiết có cùng hình dạng.

Trong một cuộc khai quật khảo cổ, bạn tìm thấy toàn bộ \(N\) cột mà xã hội này từng xây, nhưng không còn mái nào. Bạn muốn xác định một thứ tự khả dĩ mà các cột đã được xây, phù hợp với các quy tắc trên.

Một thứ tự khả dĩ là một hoán vị của \(N\) cột sao cho, với mọi tiền tố có độ dài ít nhất 4, tồn tại một mái (một đa giác lồi) chứa đầu mút của ba cột cuối cùng trong tiền tố; đồng thời, với mọi cột khác trong tiền tố có đầu mút tại \((x,y,h)\), mái chứa một điểm \((x,y,z)\) với \(z>h\).

Dữ liệu vào

Dòng đầu tiên chứa số lượng bộ test \(T\). Sau đó là \(T\) bộ test.

Mỗi bộ test bắt đầu bằng một dòng chứa số nguyên \(N\), số lượng cột. Tiếp theo là \(N\) dòng; dòng thứ \(i\) chứa ba số nguyên \(X_i\), \(Y_i\)\(H_i\), lần lượt là tọa độ X, tọa độ Y và độ cao so với mặt đất của đầu cột thứ \(i\).

Dữ liệu ra

Với mỗi bộ test, in một dòng có dạng Case #x: y1 y2 ... yN, trong đó x là số thứ tự bộ test (bắt đầu từ 1), và mỗi yi là một số nguyên khác nhau từ 1 đến \(N\). Chúng biểu diễn một thứ tự xây cột khả dĩ, trong đó yi là chỉ số trong input của cột được xây thứ \(i\).

Đề bài bảo đảm luôn có ít nhất một đáp án hợp lệ. Nếu có nhiều đáp án, bạn có thể in bất kỳ đáp án nào.

Ràng buộc

  • \(1 \le T \le 100\).
  • \(-10^6 \le X_i \le 10^6\) với mọi \(i\).
  • \(-10^6 \le Y_i \le 10^6\) với mọi \(i\).
  • \(1 \le H_i \le 10^6\) với mọi \(i\).
  • \((X_i,Y_i)\), \((X_j,Y_j)\)\((X_k,Y_k)\) không thẳng hàng với mọi bộ chỉ số \(i,j,k\) đôi một phân biệt.
  • \((X_i,Y_i,H_i)\), \((X_j,Y_j,H_j)\), \((X_k,Y_k,H_k)\)\((X_l,Y_l,H_l)\) không đồng phẳng với mọi bộ chỉ số \(i,j,k,l\) đôi một phân biệt.

Phân nhóm

  • Test Set 1 (Visible): \(4 \le N \le 10\).
  • Test Set 2 (Hidden): \(4 \le N \le 1000\).

Điểm các phân nhóm

Mỗi Test Set tương ứng với một subtask trên LQDOJ. Bảng dưới đây giữ nguyên điểm chính thức của Google Code Jam và quy đổi tỷ lệ trên tổng điểm của bài.

Phân nhóm Điểm Google Code Jam Tỷ lệ điểm của bài
Test Set 1 7/26 26,92%
Test Set 2 19/26 73,08%

Ví dụ

Ví dụ 1

Input
3
5
-1 0 3
1 2 4
1 -2 4
3 1 3
3 -1 2
4
1 1 1
2 2 3
2 3 4
10 11 120
4
1 1 1
2 2 3
2 3 4
10 11 12
Output
Case #1: 5 4 3 1 2
Case #2: 3 2 1 4
Case #3: 1 2 4 3
Giải thích

Output mẫu chỉ là một thứ tự hợp lệ cho mỗi bộ test.

Các hình sau minh họa Test mẫu #1.

Nguồn

Google Code Jam 2018, Vòng 3, bài Raise the Roof.

Nguồn chính thức trên Google Coding Competitions Archive, phát hành theo giấy phép Apache-2.0.