Viene fornita una serie di coordinate cartesiane arbitrarie, uniche, 2d, intere: ad es. [(0,0), (0,1), (1,0)]

Trova il percorso più lungo possibile da questo set di coordinate, con la limitazione che una coordinata può essere "visitata" una sola volta. (E non "ritorni" alle coordinate in cui hai iniziato).

Importante:

Non è possibile "passare sopra" una coordinata o attorno ad essa. Ad esempio, nell'ultimo esempio di nota (Rettangolo), non è possibile spostarsi da D ad A senza visitare C (che può essere una visita, invalidando la lunghezza così trovata). Lo ha sottolineato @FryAmTheEggman.

Input di funzione: matrice di coordinate cartesiane 2d
Output di funzione: solo lunghezza massima
Vincitore: il codice più corto vince, nessuna sospensione esclusa (non il più efficiente in termini di spazio-tempo)

Esempi

1 : In questo caso mostrato sopra, il percorso più lungo senza coordinate "visitate" due volte è A -> B -> O (o OBA o BAO) e la lunghezza del percorso è sqrt (2) + 1 = 2.414

2 : In questo caso mostrato sopra, il percorso più lungo senza coordinate "visitate" due volte è ABOC (e ovviamente COBA, OCAB ecc.), E per il quadrato dell'unità mostrato, calcola in sqrt (2) + sqrt (2) + 1 = 3.828.

Nota: ecco un ulteriore test case che non è così banale come i due esempi precedenti. Questo è un rettangolo formato da 6 coordinate:

Qui, il percorso più lungo è: A -> E -> C -> O -> D -> B, che è 8.7147
(diagonali massime possibili percorse e senza bordi attraversati)

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 

Provalo qui!

Mathematica, 139 byte

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

Caso di prova

%[{{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)}

Il codice supporta fino a 100 punti. Poiché produce tutte le possibili permutazioni in punti, 100 punti richiederebbero almeno 3,7 × 10 ¹³⁴ yottabyte di memoria (12 punti utilizzerebbero 1,8 Gb).

ha commentato:

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 )      
}

Casi test:

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: risparmia 19 non ripristinandoli $"e alcuni inline
• 318 byte: risparmia 4 riducendo il numero massimo di coord a 100.