पायथन: 1,688,293 1,579,182 1,524,054 1,450,842 1,093,215 चालें
मुख्य विधि है main_to_help_best, जो कुछ चुनिंदा तत्वों को मुख्य स्टैक से हेल्पर स्टैक में स्थानांतरित करना है। इसमें एक ध्वज है everythingजो परिभाषित करता है कि क्या हम चाहते हैं कि यह सब कुछ निर्दिष्ट में स्थानांतरित हो destination, या क्या हम केवल सबसे बड़ा रखना चाहते हैं destinationजबकि बाकी अन्य सहायक में।
मान लें कि हम dstसहायक का उपयोग करने के लिए आगे बढ़ रहे हैं helper, तो फ़ंक्शन को मोटे तौर पर निम्नानुसार वर्णित किया जा सकता है:
- सबसे बड़े तत्वों के पदों का पता लगाएं
- शीर्ष-सबसे बड़े तत्व के शीर्ष पर
helperपुनरावर्ती में सब कुछ ले जाएं
- के लिए सबसे बड़ा तत्व ले जाएँ
dst
helperमुख्य से वापस धक्का- 2-4 दोहराएं जब तक कि सबसे बड़े तत्व अंदर न हों
dst
- ए। यदि
everythingसेट किया गया है, तो पुन: मुख्य रूप से तत्वों को dst
b से स्थानांतरित करें । अन्यथा, पुनरावर्ती रूप से तत्वों को मुख्य रूप से स्थानांतरित करते हैंhelper
मुख्य सॉर्ट एल्गोरिथ्म ( sort2मेरे कोड में) फिर सेट के main_to_help_bestसाथ कॉल करेगा , और फिर सबसे बड़े तत्व को मुख्य में ले जाएगा, फिर हेल्पर से मुख्य तक सब कुछ स्थानांतरित करें, इसे क्रमबद्ध रखते हुए।everythingFalse
अधिक स्पष्टीकरण कोड में टिप्पणियों के रूप में एम्बेडेड है।
मूल रूप से मेरे द्वारा उपयोग किए जाने वाले सिद्धांत हैं:
- अधिकतम तत्व रखने के लिए एक सहायक रखें
- किसी भी अन्य तत्वों को शामिल करने के लिए एक और सहायक रखें
- जितना हो सके अनावश्यक चाल-चलन न करें
सिद्धांत 3 को चाल को गिनने से लागू नहीं किया जाता है यदि स्रोत पिछले गंतव्य है (यानी, हम बस हेल्प 1 में मुख्य हो गए हैं, तो हम हेल्प 1 से हेल्प 2 में जाना चाहते हैं), और आगे, हम 1 से आंदोलन की संख्या को कम करते हैं यदि हम इसे वापस मूल स्थिति में ले जा रहे हैं (यानी मुख्य मदद करने के लिए 1 फिर मदद करने के लिए मुख्य 1)। इसके अलावा, यदि पिछली nचालें सभी एक ही पूर्णांक को आगे बढ़ा रही हैं, तो हम वास्तव में उन nचालों को फिर से व्यवस्थित कर सकते हैं । इसलिए हम इसका फायदा भी उठाते हैं ताकि आगे की संख्या कम हो सके।
यह मान्य है क्योंकि हम मुख्य स्टैक में सभी तत्वों को जानते हैं, इसलिए यह व्याख्या की जा सकती है कि भविष्य में यह देखते हुए कि हम तत्व को वापस ले जा रहे हैं, हमें यह कदम नहीं उठाना चाहिए।
सैंपल रन (ढेर को नीचे से ऊपर तक प्रदर्शित किया जाता है - इसलिए पहला तत्व नीचे है):
लंबाई 1
चाल: 0
कार्य: 6
अधिकतम: 0 ([1])
औसत: 0.000
लंबाई २
चाल: 60
कार्य: 36
अधिकतम: 4 ([1, 2])
औसत: 1.667
लंबाई ३
चाल: 1030
कार्य: 216
अधिकतम: 9 ([2, 3, 1])
औसत: 4.769
लंबाई ४
चाल: 11765
कार्य: 1296
अधिकतम: 19 ([3, 4, 2, 1])
औसत: 9.078
लंबाई ५
चाल: 112325
कार्य: 7776
अधिकतम: 33 ([4, 5, 3, 2, 1])
औसत: 14.445
लंबाई ६
चाल: 968015
कार्य: 46656
अधिकतम: 51 ([5, 6, 4, 3, 2, 1])
औसत: 20.748
--------------
संपूर्ण
चाल: 1093195
कार्य: 55986
औसत: 19.526
हम देख सकते हैं कि सबसे खराब स्थिति तब होती है जब सबसे बड़े तत्व को दूसरे तल पर रखा जाता है, जबकि बाकी को छांटा जाता है। सबसे खराब स्थिति से हम देख सकते हैं कि एल्गोरिथ्म हे (n ^ 2)।
चालों की संख्या स्पष्ट रूप से न्यूनतम है n=1और n=2जैसा कि हम परिणाम से देख सकते हैं, और मेरा मानना है कि यह बड़े मूल्यों के लिए भी न्यूनतम है n, हालांकि मैं इसे साबित नहीं कर सकता।
अधिक स्पष्टीकरण कोड में हैं।
from itertools import product
DEBUG = False
def sort_better(main, help1, help2):
# Offset denotes the bottom-most position which is incorrect
offset = len(main)
ref = list(reversed(sorted(main)))
for idx, ref_el, real_el in zip(range(len(main)), ref, main):
if ref_el != real_el:
offset = idx
break
num_moves = 0
# Move the largest to help1, the rest to help2
num_moves += main_to_help_best(main, help1, help2, offset, False)
# Move the largest back to main
num_moves += push_to_main(help1, main)
# Move everything (sorted in help2) back to main, keep it sorted
num_moves += move_to_main(help2, main, help1)
return num_moves
def main_to_help_best(main, dst, helper, offset, everything=True):
"""
Moves everything to dst if everything is true,
otherwise move only the largest to dst, and the rest to helper
"""
if offset >= len(main):
return 0
max_el = -10**10
max_idx = -1
# Find the location of the top-most largest element
for idx, el in enumerate(main[offset:]):
if el >= max_el:
max_idx = idx+offset
max_el = el
num_moves = 0
# Loop from that position downwards
for max_idx in range(max_idx, offset-1, -1):
# Processing only at positions with largest element
if main[max_idx] < max_el:
continue
# The number of elements above this largest element
top_count = len(main)-max_idx-1
# Move everything above this largest element to helper
num_moves += main_to_help_best(main, helper, dst, max_idx+1)
# Move the largest to dst
num_moves += move(main, dst)
# Move back the top elements
num_moves += push_to_main(helper, main, top_count)
# Here, the largest elements are in dst, the rest are in main, not sorted
if everything:
# Move everything to dst on top of the largest
num_moves += main_to_help_best(main, dst, helper, offset)
else:
# Move everything to helper, not with the largest
num_moves += main_to_help_best(main, helper, dst, offset)
return num_moves
def verify(lst, moves):
if len(moves) == 1:
return True
moves[1][0][:] = lst
for src, dst, el in moves[1:]:
move(src, dst)
return True
def equal(*args):
return len(set(str(arg.__init__) for arg in args))==1
def move(src, dst):
dst.append(src.pop())
el = dst[-1]
if not equal(dst, sort.lst) and list(reversed(sorted(dst))) != dst:
raise Exception('HELPER NOT SORTED: %s, %s' % (src, dst))
cur_len = len(move.history)
check_idx = -1
matched = False
prev_src, prev_dst, prev_el = move.history[check_idx]
# As long as the element is the same as previous elements,
# we can reorder the moves
while el == prev_el:
if equal(src, prev_dst) and equal(dst, prev_src):
del(move.history[check_idx])
matched = True
break
elif equal(src, prev_dst):
move.history[check_idx][1] = dst
matched = True
break
elif equal(dst, prev_src):
move.history[check_idx][0] = src
matched = True
break
check_idx -= 1
prev_src, prev_dst, prev_el = move.history[check_idx]
if not matched:
move.history.append([src, dst, el])
return len(move.history)-cur_len
def push_to_main(src, main, amount=-1):
num_moves = 0
if amount == -1:
amount = len(src)
if amount == 0:
return 0
for i in range(amount):
num_moves += move(src, main)
return num_moves
def push_to_help(main, dst, amount=-1):
num_moves = 0
if amount == -1:
amount = len(main)
if amount == 0:
return 0
for i in range(amount):
num_moves += move(main, dst)
return num_moves
def help_to_help(src, dst, main, amount=-1):
num_moves = 0
if amount == -1:
amount = len(src)
if amount == 0:
return 0
# Count the number of largest elements
src_len = len(src)
base_el = src[src_len-amount]
base_idx = src_len-amount+1
while base_idx < src_len and base_el == src[base_idx]:
base_idx += 1
# Move elements which are not the largest to main
num_moves += push_to_main(src, main, src_len-base_idx)
# Move the largest to destination
num_moves += push_to_help(src, dst, base_idx+amount-src_len)
# Move back from main
num_moves += push_to_help(main, dst, src_len-base_idx)
return num_moves
def move_to_main(src, main, helper, amount=-1):
num_moves = 0
if amount == -1:
amount = len(src)
if amount == 0:
return 0
# Count the number of largest elements
src_len = len(src)
base_el = src[src_len-amount]
base_idx = src_len-amount+1
while base_idx < src_len and base_el == src[base_idx]:
base_idx += 1
# Move elements which are not the largest to helper
num_moves += help_to_help(src, helper, main, src_len-base_idx)
# Move the largest to main
num_moves += push_to_main(src, main, base_idx+amount-src_len)
# Repeat for the rest of the elements now in the other helper
num_moves += move_to_main(helper, main, src, src_len-base_idx)
return num_moves
def main():
num_tasks = 0
num_moves = 0
for n in range(1, 7):
start_moves = num_moves
start_tasks = num_tasks
max_move = -1
max_main = []
for lst in map(list,product(*[[1,2,3,4,5,6]]*n)):
num_tasks += 1
if DEBUG: print lst, [], []
sort.lst = lst
cur_lst = lst[:]
move.history = [(None, None, None)]
help1 = []
help2 = []
moves = sort_better(lst, help1, help2)
if moves > max_move:
max_move = moves
max_main = cur_lst
num_moves += moves
if DEBUG: print '%s, %s, %s (moves: %d)' % (cur_lst, [], [], moves)
if list(reversed(sorted(lst))) != lst:
print 'NOT SORTED: %s' % lst
return
if DEBUG: print
# Verify that the modified list of moves is still valid
verify(cur_lst, move.history)
end_moves = num_moves - start_moves
end_tasks = num_tasks - start_tasks
print 'Length %d\nMoves: %d\nTasks: %d\nMax: %d (%s)\nAverage: %.3f\n' % (n, end_moves, end_tasks, max_move, max_main, 1.0*end_moves/end_tasks)
print '--------------'
print 'Overall\nMoves: %d\nTasks: %d\nAverage: %.3f' % (num_moves, num_tasks, 1.0*num_moves/num_tasks)
# Old sort method, which assumes we can only see the top of the stack
def sort(main, max_stack, a_stack):
height = len(main)
largest = -1
num_moves = 0
a_stack_second_el = 10**10
for i in range(height):
if len(main)==0:
break
el = main[-1]
if el > largest: # We found a new maximum element
if i < height-1: # Process only if it is not at the bottom of main stack
largest = el
if len(a_stack)>0 and a_stack[-1] < max_stack[-1] < a_stack_second_el:
a_stack_second_el = max_stack[-1]
# Move aux stack to max stack then reverse the role
num_moves += help_to_help(a_stack, max_stack, main)
max_stack, a_stack = a_stack, max_stack
if DEBUG: print 'Moved max_stack to a_stack: %s, %s, %s (moves: %d)' % (main, max_stack, a_stack, num_moves)
num_moves += move(main, max_stack)
if DEBUG: print 'Moved el to max_stack: %s, %s, %s (moves: %d)' % (main, max_stack, a_stack, num_moves)
elif el == largest:
# The maximum element is the same as in max stack, append
if i < height-1: # Only if the maximum element is not at the bottom
num_moves += move(main, max_stack)
elif len(a_stack)==0 or el <= a_stack[-1]:
# Current element is the same as in aux stack, append
if len(a_stack)>0 and el < a_stack[-1]:
a_stack_second_el = a_stack[-1]
num_moves += move(main, a_stack)
elif a_stack[-1] < el <= a_stack_second_el:
# Current element is larger, but smaller than the next largest element
# Step 1
# Move the smallest element(s) in aux stack into max stack
amount = 0
while len(a_stack)>0 and a_stack[-1] != a_stack_second_el:
num_moves += move(a_stack, max_stack)
amount += 1
# Step 2
# Move all elements in main stack that is between the smallest
# element in aux stack and current element
while len(main)>0 and max_stack[-1] <= main[-1] <= el:
if max_stack[-1] < main[-1] < a_stack_second_el:
a_stack_second_el = main[-1]
num_moves += move(main, a_stack)
el = a_stack[-1]
# Step 3
# Put the smallest element(s) back
for i in range(amount):
num_moves += move(max_stack, a_stack)
else: # Find a location in aux stack to put current element
# Step 1
# Move all elements into max stack as long as it will still
# fulfill the Hanoi condition on max stack, AND
# it should be greater than the smallest element in aux stack
# So that we won't duplicate work, because in Step 2 we want
# the main stack to contain the minimum element
while len(main)>0 and a_stack[-1] < main[-1] <= max_stack[-1]:
num_moves += move(main, max_stack)
# Step 2
# Pick the minimum between max stack and aux stack, move to main
# This will essentially sort (in reverse) the elements into main
# Don't move to main the element(s) found before Step 1, because
# we want to move them to aux stack
while True:
if len(a_stack)>0 and a_stack[-1] < max_stack[-1]:
num_moves += move(a_stack, main)
elif max_stack[-1] < el:
num_moves += move(max_stack, main)
else:
break
# Step 3
# Move all elements in main into aux stack, as long as it
# satisfies the Hanoi condition on aux stack
while max_stack[-1] == el:
num_moves += move(max_stack, a_stack)
while len(main)>0 and main[-1] <= a_stack[-1]:
if main[-1] < a_stack[-1] < a_stack_second_el:
a_stack_second_el = a_stack[-1]
num_moves += move(main, a_stack)
if DEBUG: print main, max_stack, a_stack
# Now max stack contains largest element(s), aux stack the rest
num_moves += push_to_main(max_stack, main)
num_moves += move_to_main(a_stack, main, max_stack)
return num_moves
if __name__ == '__main__':
main()