Bạn được cung cấp một tập hợp tọa độ Cartesian số nguyên, duy nhất, 2d, số nguyên: vd [(0,0), (0,1), (1,0)]

Tìm đường dẫn dài nhất có thể từ bộ tọa độ này, với hạn chế là tọa độ chỉ có thể được "truy cập" một lần. (Và bạn không "quay lại" với tọa độ bạn đã bắt đầu).

Quan trọng:

Bạn không thể "vượt qua" một tọa độ hoặc xung quanh nó. Chẳng hạn, trong ví dụ ghi chú cuối cùng (Hình chữ nhật), bạn không thể di chuyển từ D sang A mà không truy cập C (có thể là xem lại, làm mất hiệu lực độ dài do đó tìm thấy). Điều này đã được chỉ ra bởi @FryAmTheEggman.

Đầu vào chức năng: Mảng của tọa độ Cartesian 2d
Đầu ra chức năng: Chỉ độ dài tối đa
Người chiến thắng: Mã ngắn nhất thắng, không bị cấm (Không phải là hiệu quả nhất về không gian)

Ví dụ

1 : Trong trường hợp này được hiển thị ở trên, đường dẫn dài nhất không có tọa độ "truy cập" hai lần là A -> B -> O (hoặc OBA hoặc BAO) và độ dài đường dẫn là sqrt (2) + 1 = 2.414

2 : Trong trường hợp được hiển thị ở trên, đường dẫn dài nhất không có tọa độ "truy cập" hai lần là ABOC (và rõ ràng là COBA, OCAB, v.v.) và đối với hình vuông đơn vị được hiển thị, nó tính toán thành sqrt (2) + sqrt (2) + 1 = 3,828.

Lưu ý: Đây là một trường hợp thử nghiệm bổ sung không tầm thường như hai ví dụ trước. Đây là một hình chữ nhật được hình thành từ 6 tọa độ:

Ở đây, con đường dài nhất là: A -> E -> C -> O -> D -> B, là 8.7147
(đường chéo tối đa có thể đi và không có cạnh nào đi qua)

Pyth, 105 103 100 92 86 byte

V.pQK0FktlNJ.a[@Nk@Nhk)FdlNI&!qdk&!qdhkq+.a[@Nk@Nd).a[@Nd@Nhk)J=K.n5B)=K+KJ)IgKZ=ZK))Z

              Z = 0 - value of longest path
              Q = eval(input())

V.pQ         for N in permutations(Q):
  K0           K = 0 - value of current path
  FktlN        for k in len(N) - 1:
    J.a          set J = distance of
    [@Nk                 Q[k] and Q[k+1]
    @Nhk)    
    FdlN         for d in len(N):
I&                 if d != k && d != (k + 1)
!qdk
&!qdhk
q+                and if sum of
.a                   distance Q[k] and Q[d]
 [@Nk                
 @Nd)                
.a                   distance Q[d] and Q[k+1]
 [@Nd
 @Nhk)
J                    are equal to J then
  =K.n5              set K to -Infinity
  B                  and break loop
                     ( it means that we passed over point )
  )                   end of two if statements
=K+KJ                  K+=J add distance to our length
)                      end of for
IgKZ                   if K >= Z - if we found same or better path
  =ZK                  Z = K       set it to out max variable
))                     end of two for statements
Z                      output value of longest path 

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

Toán học, 139 byte

Max[Tr@BlockMap[If[1##&@@(Im[#/#2]&@@@Outer[#/Abs@#&[#-#2]&,l~Complement~#,#])==0,-∞,Abs[{1,-1}.#]]&,#,2,1]&/@Permutations[l=#+I#2&@@@#]]&

Trường hợp thử nghiệm

%[{{0,0},{0,1},{1,0},{1,1},{2,0},{2,1}}]
(* 3 Sqrt[2]+2 Sqrt[5] *)

%//N
(* 8.71478 *)

Perl, 341 322 318 byte

sub f{@g=map{$_<10?"0$_":$_}0..$#_;$"=',';@l=grep{"@g"eq join$",sort/../g}glob"{@g}"x(@i=@_);map{@c=/../g;$s=0;$v=1;for$k(1..$#c){$s+=$D=d($k-1,$k);$_!=$k&&$_!=$k-1&&$D==d($_,$k)+d($_,$k-1)and$v=0 for 0..$#c}$m=$s if$m<$s&&$v}@l;$m}sub d{@a=@{$i[$c[$_[0]]]};@b=@{$i[$c[$_[1]]]};sqrt(($a[0]-$b[0])**2+($a[1]-$b[1])**2)}

Mã hỗ trợ lên tới 100 điểm. Vì nó tạo ra tất cả các hoán vị điểm có thể, 100 điểm sẽ cần ít nhất 3,7 × 10 ¹³⁴ yottabyte bộ nhớ (12 điểm sẽ sử dụng 1,8Gb).

Đã bình luận:

sub f {
    @g = map { $_<10 ? "0$_" : $_ } 0..$#_; # generate fixed-width path indices
    $" = ',';                               # set $LIST_SEPARATOR to comma for glob
    @l = grep {                             # only iterate paths with unique points
        "@g" eq join $", sort /../g         # compare sorted indices with unique indices
    } glob "{@g}" x (@i=@_);                # produce all permutations of path indices
                                            # and save @_ in @i for sub d
    map {
        @c = /../g;                         # unpack the path indices
        $s=0;                               # total path length
        $v=1;                               # validity flag
        for $k (1..$#c) {                   # iterate path
            $s +=                           # sum path length
                $D = d( $k-1, $k );         # line distance 

              $_!=$k && $_!=$k-1            # except for the current line,
              && $D == d( $_, $k )          # if the point is on the line,
                     + d( $_, $k-1 )
              and $v = 0                    # then reset it's validity
            for 0 .. $#c                    # iterate path again to check all points
        }
        $m=$s if $m<$s && $v                # update maximum path length
    } @l;
    $m                                      # return the max
}

sub d {                                     
    @a = @{ $i[$c[$_[0]]] };                # resolve the index $_[0] to the first coord
    @b = @{ $i[$c[$_[1]]] };                # idem for $_[1]
    sqrt( ($a[0] - $b[0])**2       
        + ($a[1] - $b[1])**2 )      
}

TestCase:

print f( [0,1], [0,0], [1,0] ), $/;        $m=0; # reset max for next call
print f( [0,0], [0,1], [1,0], [1,1] ), $/; $m=0;
print f( [0,0], [0,1], [0,2] ), $/;        $m=0;
print f( [0,0], [0,1], [0,2], 
         [1,0], [1,1], [1,2]),$/;          $m=0;

• 322 byte: lưu 19 bằng cách không đặt lại $"và một số nội tuyến
• 318 byte: lưu 4 bằng cách giảm tối đa nr của coords xuống 100.