Giả sử bạn có một bộ các số nguyên. Có thể một số bộ sẽ chồng lấp (tức là các phần tử chia sẻ). Bạn có thể thoát khỏi sự chồng chéo bằng cách xóa các phần tử khỏi các tập hợp, nhưng sau đó một số trong số chúng có thể kết thúc trống; đó sẽ là một sự xấu hổ Chúng ta có thể làm cho tất cả các bộ tách rời nhau mà không làm trống bất kỳ bộ nào không?

Lưu ý rằng trong tình huống này, không bao giờ có bất kỳ lý do nào để để lại nhiều phần tử trong một tập hợp, vì vậy vấn đề này luôn có thể được giải quyết bằng cách giảm mỗi bộ thành chỉ một phần tử. Đó là phiên bản của vấn đề chúng tôi đang giải quyết ở đây.

Nhiệm vụ

Viết chương trình hoặc hàm, như sau:

Đầu vào : Một danh sách các bộ số nguyên.

Đầu ra : Một danh sách các số nguyên, có cùng độ dài với đầu vào, trong đó:

• Tất cả các số nguyên trong đầu ra là khác biệt; và
• Mỗi số nguyên trong đầu ra là một phần tử của tập hợp đầu vào tương ứng.

Làm rõ

• Bạn có thể biểu diễn một tập hợp dưới dạng danh sách nếu bạn muốn (hoặc bất cứ điều gì phù hợp với ngôn ngữ của bạn), bỏ qua thứ tự các yếu tố.
• Bạn không phải xử lý trường hợp không có giải pháp tồn tại (nghĩa là sẽ luôn có ít nhất một giải pháp).
• Có thể có nhiều hơn một giải pháp. Thuật toán của bạn phải luôn tạo ra một giải pháp hợp lệ, nhưng được phép không đặc biệt (nghĩa là nó ổn nếu nó chọn một giải pháp hợp lệ khác nhau mỗi lần nó chạy).
• Số lượng số nguyên riêng biệt xuất hiện trong đầu vào, n , sẽ bằng số lượng bộ trong đầu vào và để đơn giản, sẽ là các số nguyên từ 1 đến n bao gồm (vì giá trị thực của chúng không quan trọng). Tùy thuộc vào việc bạn có muốn khai thác sự thật này hay không.

Tủ thử

[{1,2},{1,3},{1,4},{3,4}] -> [2,3,1,4] or [2,1,4,3]
[{1,3},{1,2,4},{2,3},{3},{2,3,4,5}] -> [1,4,2,3,5]
[{1,3,4},{2,3,5},{1,2},{4,5},{4,5}] -> [1,3,2,4,5] or [3,2,1,4,5] or [1,3,2,5,4] or [3,2,1,5,4]

Điều kiện chiến thắng

Một chương trình đòi hỏi độ phức tạp thời gian tối ưu để giành chiến thắng, tức là nếu một thuật toán có độ phức tạp thời gian tốt hơn được tìm thấy, nó sẽ loại bỏ tất cả các mục chậm hơn. (Bạn có thể giả sử rằng các nội dung trong ngôn ngữ của bạn chạy càng nhanh càng tốt, ví dụ: bạn có thể giả sử rằng một nội dung sắp xếp chạy trong thời gian O (n log n). Tương tự, giả sử rằng tất cả các số nguyên có kích thước tương đương với n có thể được thêm, nhân, v.v. trong thời gian không đổi.)

Bởi vì độ phức tạp thời gian tối ưu có thể khá dễ dàng đạt được trong hầu hết các ngôn ngữ, do đó, người chiến thắng sẽ là chương trình ngắn nhất trong số những ngôn ngữ có độ phức tạp thời gian chiến thắng, được đo bằng byte.

Thạch , 8 byte

Œp⁼Q$ÐfḢ

Hãy thử trực tuyến!

Giải trình

Œp⁼Q$ÐfḢ  Main Link
Œp        Cartesian Product of the elements; all possible lists
     Ðf   Filter; keep elements that are
  ⁼Q$     Equal to themselves uniquified
      Ḣ   Take the first one

Vô cùng kém hiệu quả. Không triệu chứng ϴ(n^(n+1))theo Misha Lavrov; Tôi nghĩ nó đúng.

Ngôn ngữ Wolfram (Mathicala) , 87 byte và (n ³ )

-Range[n=Length@#]/.Rule@@@FindIndependentEdgeSet[Join@@Table[-i->j,{i,n},{j,#[[i]]}]]&

Hãy thử trực tuyến!

Xây dựng một đồ thị hai phía có đỉnh ở một bên là những bộ (lập chỉ mục -1,-2,...,-n) và có đỉnh ở phía bên kia là những yếu tố 1,2,...,n, với một cạnh từ -iđến jkhi jđược chứa trong các ibộ -thứ. Tìm một kết hợp hoàn hảo trong biểu đồ này bằng cách sử dụng tích hợp. Sau đó liệt kê ra các yếu tố tương ứng -1,-2,...,-ntheo thứ tự đó trong kết hợp hoàn hảo.

Mathematica FindIndependentEdgeSetlà nút cổ chai ở đây; mọi thứ khác cần các thao tác O (n ² ) để làm. Mathematica có thể sử dụng thuật toán Hungary , và vì vậy tôi sẽ cho rằng nó chạy trong thời gian ϴ (n ³ ) , mặc dù có thể Mathicala có một triển khai ngây thơ với độ phức tạp O (n ⁴ ).

Haskell , 48 byte

-1 byte nhờ nimi.

import Data.List
head.filter((==)<*>nub).mapM id

Hãy thử trực tuyến!

Toán học 39 byte

Last@Union[DeleteDuplicates/@Tuples@#]&

Về vấn đề phức tạp, tôi nghĩ nó phụ thuộc rất nhiều vào độ dài của mỗi danh sách con, cũng như thước đo mức độ phân biệt các danh sách con.

Vì vậy, tôi nghĩ thuật toán này là O (n Log n + n ^ 2 Log m) trong đó m có độ dài trung bình của mỗi danh sách con.

Một cái gì đó như thế này sẽ có độ phức tạp O (a ^ n) trong đó a> 1 là thước đo sự chồng chéo trong danh sách con:

(For[x={1,1},!DuplicateFreeQ@x,x=RandomChoice/@#];x)&

Khó có thể nói cái nào thực sự nhanh hơn mà không biết các thuộc tính của đầu vào có thể.

05AB1E , 13 byte, O (n! * N)

āœʒ‚øε`QO}P}н

Hãy thử trực tuyến! Giải trình:

ā               Make a range 1..n
 œ              Generate all permutations
  ʒ        }    Filter
   ‚ø           Zip with input
     ε   }      Loop over sets
      `QO       Check each element for membership
          P     All sets must match
            н   Take the first result

Husk , 5 byte

►oLuΠ

Hãy thử trực tuyến!

Giải trình

Chỉ thấy điều phức tạp: Thông thường, đó là trường hợp với giải pháp của ngôn ngữ chơi gôn, chúng không hiệu quả lắm - cái này có độ phức tạp O (n · nⁿ).

►(Lu)Π  -- input as a list of lists, for example: [[1,2],[1,3],[1,4],[3,4]]
     Π  -- cartesian product: [[1,1,1,3],...,[2,3,4,4]]
►(  )   -- maximum by the following function (eg. on [1,1,1,3]):
   u    --   deduplicate: [1,3]
  L     --   length: 2

Pyth , 9 byte ((n ^{n + 1} ))

Vì điều này hoạt động chính xác như giải pháp Jelly, rất có thể nó có độ phức tạp tương tự.

h{I#.nM*F

Hãy thử nó ở đây!

Làm sao?

h {I # .nM * F | Chương trình đầy đủ.

       * F | Gấp sản phẩm của Cartesian.
    .nM | Làm phẳng từng cái.
   # | Giữ những thứ đó:
 {I Đó là bất biến đối với việc loại bỏ các yếu tố trùng lặp.
h | Lấy yếu tố đầu tiên.

JavaScript (ES6), 74 73 byte

Đã lưu 1 byte, nhờ @Neil.

f=([a,...A],s=[],S)=>a?a.map(c=>s.includes(c)||(S=S||f(A,[...s,c])))&&S:s

Lặp lại đệ quy thông qua các mảng tìm kiếm một giải pháp.

Ung dung:

f=(
   [a, ...A],                        //a is the first array, A is the rest
   s = [],                           //s is the current trial solution
   S                                 //S holds the solution (if one exists) at this branch
  )=>
     a ? a.map(                      //if we're not done, iterate through a
           c => s.includes(c) ||     //  if this element already exists, short-circuit
                (S = S ||            //  else if S has a solution, keep it
                 f(A, [...s, c])     //  else look for a solution down this branch
                )
         ) && S                      //return S

Các trường hợp thử nghiệm:

f=([a,...A],s=[],S)=>a?a.map(c=>s.includes(c)||(S=S||f(A,[...s,c])))&&S:s

console.log(f([[1,2],[1,3],[1,4],[3,4]])) // [2,3,1,4] or [2,1,4,3]
console.log(f([[1,3],[1,2,4],[2,3],[3],[2,3,4,5]])) // [1,4,2,3,5]
console.log(f([[1,3,4],[2,3,5],[1,2],[4,5],[4,5]])) // [1,3,2,4,5] or [3,2,1,4,5] or [1,3,2,5,4] or [3,2,1,5,4],4]

Python3, 93 84 byte

-9 byte nhờ caird coinheringaahing

lambda I:next(filter(lambda x:len(x)==len({*x}),product(*I)))
from itertools import*

Hãy thử trực tuyến!