2d विमान पर सबसे लंबा रास्ता

Question

आपको मध्यस्थ, अद्वितीय, 2d, पूर्णांक कार्टेशियन निर्देशांक का एक सेट प्रदान किया जाता है: जैसे [(0,0), (0,1), (1,0)]

निर्देशांक के इस सेट से संभव सबसे लंबा रास्ता खोजें, इस प्रतिबंध के साथ कि एक समन्वय केवल एक बार "दौरा" किया जा सकता है। (और आपके द्वारा शुरू किए गए समन्वय के लिए आप "वापस नहीं आते")।

महत्वपूर्ण:

आप एक समन्वय या इसके आसपास "पास" नहीं कर सकते। उदाहरण के लिए, पिछले टिप्पणी उदाहरण (आयत) में, आप डी से एक को स्थानांतरित नहीं कर सकते बिना सी पर जाकर (जो एक फिर से आना हो सकता है, इस प्रकार पाया लंबाई अमान्य)। यह @FryAmTheEggman द्वारा इंगित किया गया था।

समारोह इनपुट: 2d कार्टेशियन निर्देशांक की सरणी
फ़ंक्शन आउटपुट: अधिकतम लंबाई केवल
विजेता: सबसे छोटा कोड जीतता है, कोई रोक नहीं (सबसे अधिक स्थान-समय कुशल नहीं)

---

उदाहरण

1 : ऊपर दिखाए गए इस मामले में, बिना किसी समन्वय के सबसे लंबा रास्ता दो बार ए -> बी -> ओ - (या ओबीए, या बीएओ) का है, और पथ की लंबाई sqrt (2) + 1 = 2.414 है

---

2 : ऊपर दिखाए गए इस मामले में, बिना किसी समन्वय के सबसे लंबा रास्ता "विज़िट किया गया" दो बार ABOC है (और जाहिर है COBA, OCAB आदि), और दिखाए गए यूनिट स्क्वायर के लिए, यह sqrt (2) + sqrt (2+) की गणना करता है। 1 = 3.828।

---

नोट: यहां एक अतिरिक्त परीक्षण मामला है जो दो पिछले उदाहरणों के रूप में तुच्छ नहीं है। यह 6 निर्देशांकों से बनी आयत है:

यहाँ, सबसे लंबा रास्ता है: A -> E -> C -> O -> D -> B, जो 8.7147 है
(अधिकतम संभव विकर्ण चलते हैं और कोई किनारा नहीं है)

Comments

यहां एक समान प्रश्न है , अलग-अलग स्कोरिंग के साथ।

— जॉयोबिट्स

@Geobits सहमत हैं, लेकिन मैं "बहुत" नहीं कहूंगा, समस्या के वर्णन के माध्यम से वहाँ गया था। और उस मामले के लिए, किसी भी न्यूनतम / अधिकतम पथ की समस्या अनिवार्य रूप से आपके सामान्य ग्राफ संदिग्धों के कुछ स्वाद है। मैं यहाँ एक बाइट बचत समाधान में रुचि रखता हूँ।

— ब्लूपिल

@ जानलेवा काम किया। यह 8.7147 है।

— ब्लूपिल

वैसे: PPCG में आपका स्वागत है!

— घातक

@ भाग्य का शुक्रिया! (वास्तव में मैं थोड़ी देर के लिए यहां पर्यवेक्षक रहा हूं, बस सक्रिय हो गया और आज से शुरू होने वाली पूरी बात में)। :)

— ब्लूपेल

Answer 1

पायथ, 105 103 100 92 86 बाइट्स

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 

यहाँ यह कोशिश करो!

Answer 2

गणितज्ञ, १३ ९ बाइट्स

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

---

परीक्षण का मामला

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

%//N
(* 8.71478 *)

Answer 3

पर्ल, 341 322 318 बाइट्स

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

कोड 100 अंकों तक का समर्थन करता है। चूँकि यह सभी संभावित बिंदु क्रमोन्नति का उत्पादन करता है, 100 अंकों के लिए कम से कम 3.7 × 10 ¹³⁴ yottabytes मेमोरी की आवश्यकता होगी (12 अंक 1.8Gb का उपयोग करेगा)।

टिप्पणी की:

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

परीक्षण के मामलों:

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 बाइट्स: रीसेट न करके 19 बचाएं $"और कुछ इनलाइनिंग करें
• 318 बाइट्स: कोर्ड्स की अधिकतम एनआर को 100 तक घटाकर 4 बचाएं।