Trong thử thách này, bạn được thông qua hai điều:

1. Độ dài chuỗi, N
2. Một danh sách các chuỗi, Lmỗi chuỗi có một giá trị điểm được gán. Bất kỳ chuỗi nào không được truyền vào đều có giá trị điểm là 0

Bạn cần xây dựng một chuỗi độ dài Nsao cho tổng của tất cả các điểm của chuỗi con càng lớn càng tốt.

Ví dụ:

5 [("ABC", 3), ("DEF", 4), ("CDG", 2)]

nên đầu ra

ABCDG

Bởi vì hai chuỗi con có điểm ( ABCvà CDG) có tổng cộng 5 điểm và không có cấu trúc nào khác có thể cho 5 điểm trở lên.

Các lớp nền có thể được sử dụng nhiều lần trong một chuỗi và có thể chồng lên nhau. Bạn có thể giả định rằng các điểm sẽ luôn dương, độ dài chuỗi con sẽ nằm trong khoảng từ 1 đến các Nký tự và điều đó N > 0. Nếu nhiều công trình là tối đa, hãy in bất kỳ một trong số chúng.

Chương trình của bạn phải chạy trong một khoảng thời gian hợp lý (không quá một phút cho mỗi ví dụ):

1 [("A", 7), ("B", 4), ("C", 100)]     => C
2 [("A", 2), ("B", 3), ("AB", 2)]      => AB
2 [("A", 1), ("B", 2), ("CD", 3)]      => BB
2 [("AD", 1), ("B", 2), ("ZB", 3)]     => ZB
3 [("AB", 2), ("BC", 1), ("CA", 3)]    => CAB
3 [("ABC", 4), ("DEF", 4), ("E", 1)]   => DEF
4 [("A", 1), ("BAB", 2), ("ABCD", 3)]  => AAAA or ABAB or BABA or ABCD
5 [("A", 1), ("BAB", 2), ("ABCD", 3)]  => BABCD or BABAB
5 [("ABC", 3), ("DEF", 4), ("CDG", 2)] => ABCDG
5 [("AB", 10), ("BC", 2), ("CA", 2)]   => ABCAB
6 [("AB", 10), ("BC", 2), ("CA", 2)]   => ABABAB
8 [("AA", 3), ("BA", 5)]               => BAAAAAAA
10 [("ABCDE", 19), ("ACEBD",  18), ("ABEDC", 17), ("BCEDA", 16), ("EBDAC", 15), ("BACD", 14), ("CADB", 13), ("ABDC", 12), ("CABD", 11), ("EBDC", 10), ("ACE", 9), ("CBA", 8), ("AEC", 7), ("BE", 6), ("AE", 5), ("DC", 4), ("BA", 3), ("A", 2), ("D", 1)]
=> ACEBDACEBD

Đây là một môn đánh gôn , vì vậy hãy chuẩn bị câu trả lời ngắn nhất bằng ngôn ngữ yêu thích của bạn!

Python 2.7, 503 byte

Đây không phải là đặc biệt chơi golf, cũng không phải là đặc biệt hiệu quả; nó chỉ là một bảng liệt kê tương đối cô đọng của các chuỗi khả thi bị ép buộc. Tôi không nghĩ rằng sẽ quá khó để tạo ra một heuristic đáng ngưỡng mộ để sử dụng với A *, có lẽ sẽ nhanh hơn một chút. Mặc dù vậy, tôi không bận tâm làm điều đó bởi vì phương pháp này giải quyết tất cả các ví dụ trong khoảng 47 giây trên máy tính xách tay của tôi.

import re
v=lambda l,s:sum([len([m.start() for m in re.finditer('(?=%s)'%u,s)])*v for u,v in l])
def m(n,l,e):
 if len(e)==n:
  yield e
 else:
  u=1
  for s,v in sorted(l,key=lambda j:j[1],reverse=True):
   for i in range(len(s)-1,0,-1):
    if len(e)+len(s)-i <= n and e.endswith(s[:i]):
     for r in m(n,l,e+s[i:]):
      u=0;yield r
   if len(e)+len(s)<=n:
    for r in m(n,l,e+s):
     u=0;yield r
  if u:
   yield e
def p(n,l):
 b,r=-1,0
 for s in m(n,l,''):
  a=v(l,s)
  if a>b:b,r=a,s
 return r

Để kiểm tra nó:

if __name__ == "__main__":
    for n, l in [
            (1, [("A", 7), ("B", 4), ("C", 100)]),     # => C
            (2, [("A", 2), ("B", 3), ("AB", 2)]),      # => AB
            (2, [("A", 1), ("B", 2), ("CD", 3)]),      # => BB
            (2, [("AD", 1), ("B", 2), ("ZB", 3)]),     # => ZB
            (3, [("AB", 2), ("BC", 1), ("CA", 3)]),    # => CAB
            (3, [("ABC", 4), ("DEF", 4), ("E", 1)]),   # => DEF
            (4, [("A", 1), ("BAB", 2), ("ABCD", 3)]),  # => AAAA or ABAB or BABA or ABCD
            (5, [("A", 1), ("BAB", 2), ("ABCD", 3)]),  # => BABCD or BABAB
            (5, [("ABC", 3), ("DEF", 4), ("CDG", 2)]), # => ABCDG
            (5, [("AB", 10), ("BC", 2), ("CA", 2)]),   # => ABCAB
            (6, [("AB", 10), ("BC", 2), ("CA", 2)]),   # => ABABAB
            (8, [("AA", 3), ("BA", 5)]),               # => BAAAAAAA
            (10, [("ABCDE", 19), ("ACEBD",  18), ("ABEDC", 17), ("BCEDA", 16), ("EBDAC", 15), ("BACD", 14), ("CADB", 13), ("ABDC", 12), ("CABD", 11), ("EBDC", 10), ("ACE", 9), ("CBA", 8), ("AEC", 7), ("BE", 6), ("AE", 5), ("DC", 4), ("BA", 3), ("A", 2), ("D", 1)]) # => ACEBDACEBD
    ]:
        print p(n, l)

Giải trình

Các vchức năng đơn giản là tính toán giá trị của một chuỗi cho trước bằng cách tìm kiếm cho tất cả các lần xuất hiện của chuỗi con trong L. Các mchức năng liệt kê tất cả các chuỗi có độ dài nvới tiền tố ecó thể được tạo ra từ các chuỗi con trong l. mđệ quy gọi chính nó; cuộc gọi đầu tiên sẽ chuyển qua ''cho e. Ví dụ:

>>> for s in m(4, [("A", 1), ("BAB", 2), ("ABCD", 3)], ''):print s
ABCD
BABA
ABCD
ABAB
AAAA

Các pchức năng đơn giản là vòng qua tất cả các chuỗi có thể (như được liệt kê bởi m) và trả về một với giá trị cao nhất (được xác định bởi v).

Lưu ý rằng mhàm thực sự ưu tiên liệt kê bằng cách sắp xếp dựa trên các giá trị của chuỗi con. Điều này hóa ra là không cần thiết để đảm bảo sự tối ưu, và nó thực sự cản trở hiệu quả một chút; Tôi có thể tiết kiệm ~ 20 hoặc hơn byte bằng cách loại bỏ nó.