এন এর সাথে স্ট্যাকের সংখ্যা এন এবং এনপিএস স্ট্যাকের একটি সেট দেওয়া হয়েছে এবং পি স্ট্যাকের ক্ষমতা হওয়ায় আমি কীভাবে নোড থেকে কিছু স্বেচ্ছাসেবক অবস্থান বিতে নোড থেকে ন্যূনতম স্বাপগুলি গণনা করতে পারি? আমি একটি গেম ডিজাইন করছি, এবং শেষ লক্ষ্যটি হ'ল সমস্ত স্ট্যাককে বাছাই করা যাতে সেগুলি সব একই রঙের হয়।
# Let "-" represent blank spaces, and assume the stacks are
stacks = [
['R', 'R', 'R', 'R'],
['Y', 'Y', 'Y', 'Y'],
['G', 'G', 'G', 'G'],
['-', '-', '-', 'B'],
['-', 'B', 'B', 'B']
]আমি "B" Insert করতে চান, stacks[1][1]যেমন যে stacks[1] = ["-", "B", "Y", "Y"]। এটি করার জন্য প্রয়োজনীয় ন্যূনতম সংখ্যা আমি কীভাবে নির্ধারণ করতে পারি?
আমি একাধিক পদ্ধতির দিকে নজর রেখেছি, আমি জেনেটিক অ্যালগরিদমগুলি চেষ্টা করেছি যা একটি রাষ্ট্র থেকে সমস্ত সম্ভাব্য পদক্ষেপ উত্পন্ন করে, স্কোর করে এবং তারপরে সেরা স্কোরিংয়ের পথ অব্যাহত রাখে, আমি সমস্যাটি নিয়ে পাথ ফাইন্ডিংয়ের জন্য জিকিস্ট্রার অ্যালগরিদম চালানোর চেষ্টাও করেছি । হতাশাজনকভাবে সহজ বলে মনে হচ্ছে, তবুও এটি ক্ষতিকারক সময় ব্যতীত অন্য কোনও কিছুতে চালানোর কোনও উপায় আমি বের করতে পারি না। আমি এখানে কি প্রযোজ্য তা অ্যালগরিদম অনুপস্থিত আছে?
সম্পাদন করা
প্রয়োজনীয় পদক্ষেপের ন্যূনতম সংখ্যার গণনা করার জন্য আমি এই ফাংশনটি লিখেছি: স্ট্যাকস: স্ট্যাকের টুকরোগুলি প্রতিনিধিত্ব করে অক্ষরের তালিকার তালিকা [২] [0] স্ট্যাকের শীর্ষ [0] স্ট্যাক_ইন্ড: সূচকের সূচক এই স্ট্যাকটি যে টুকরোটি প্রয়োজন_পিস যুক্ত হবে: যে অংশটি স্ট্যাকের সাথে যুক্ত করা উচিত need_index: সেই সূচি যেখানে টুকরোটি থাকা উচিত
def calculate_min_moves(stacks, stack_ind, needs_piece, needs_index):
# Minimum moves needed to empty the stack that will receive the piece so that it can hold the piece
num_removals = 0
for s in stacks[stack_ind][:needs_index+1]:
if item != "-":
num_removals += 1
min_to_unlock = 1000
unlock_from = -1
for i, stack in enumerate(stacks):
if i != stack_ind:
for k, piece in enumerate(stack):
if piece == needs_piece:
if k < min_to_unlock:
min_to_unlock = k
unlock_from = i
num_free_spaces = 0
free_space_map = {}
for i, stack in enumerate(stacks):
if i != stack_ind and i != unlock_from:
c = stack.count("-")
num_free_spaces += c
free_space_map[i] = c
if num_removals + min_to_unlock <= num_free_spaces:
print("No shuffling needed, there's enough free space to move all the extra nodes out of the way")
else:
# HERE
print("case 2, things need shuffled")
সম্পাদনা: স্ট্যাকের উপর পরীক্ষার কেস:
stacks = [
['R', 'R', 'R', 'R'],
['Y', 'Y', 'Y', 'Y'],
['G', 'G', 'G', 'G'],
['-', '-', '-', 'B'],
['-', 'B', 'B', 'B']
]
Case 1: stacks[4][1] should be 'G'
Move 'B' from stacks[4][1] to stacks[3][2]
Move 'G' from stacks[2][0] to stacks[4][1]
num_removals = 0 # 'G' is directly accessible as the top of stack 2
min_to_unlock = 1 # stack 4 has 1 piece that needs removed
free_spaces = 3 # stack 3 has free spaces and no pieces need moved to or from it
moves = [[4, 3], [2, 4]]
min_moves = 2
# This is easy to calculate
Case 2: stacks[0][3] should be 'B'
Move 'B' from stacks[3][3] to stack[4][0]
Move 'R' from stacks[0][0] to stacks[3][3]
Move 'R' from stacks[0][1] to stacks[3][2]
Move 'R' from stacks[0][2] to stacks[3][1]
Move 'R' from stacks[0][3] to stacks[3][0]
Move 'B' from stacks[4][0] to stacks[0][3]
num_removals = 0 # 'B' is directly accessible
min_to_unlock = 4 # stack 0 has 4 pieces that need removed
free_spaces = 3 # If stack 3 and 4 were switched this would be 1
moves = [[3, 4], [0, 3], [0, 3], [0, 3], [0, 3], [4, 0]]
min_moves = 6
#This is hard to calculateআসল কোড বাস্তবায়ন যে অংশটি কঠিন তা নয়, এটি একটি অ্যালগরিদমকে কীভাবে কার্যকর করতে হবে তা নির্ধারণ করে যা আমি যে সমস্যার সাথে লড়াই করছি sol
প্রতি @ YonIif অনুরোধ হিসাবে আমি একটি তৈরি করেছি সারকথা সমস্যার জন্য।
এটি যখন চলতে থাকে, তখন এটি স্ট্যাকের একটি এলোমেলো অ্যারে তৈরি করে এবং একটি এলোমেলো টুকরো বেছে নেয় যা এলোমেলো স্থানে একটি এলোমেলো স্ট্যাকের মধ্যে inোকানো প্রয়োজন।
এটি চালানো কনসোলে এই বিন্যাসের কিছু মুদ্রণ করে।
All Stacks: [['-', '-', 'O', 'Y'], ['-', 'P', 'P', 'O'], ['-', 'P', 'O', 'Y'], ['Y', 'Y', 'O', 'P']]
Stack 0 is currently ['-', '-', 'O', 'Y']
Stack 0 should be ['-', '-', '-', 'P']অবস্থা হালনাগাদ
আমি এই সমস্যাটি কোনওভাবে সমাধান করতে খুব দৃ determined ়প্রতিজ্ঞ ।
মনে রাখবেন যে মামলার সংখ্যা হ্রাস করার উপায় রয়েছে, যেমন মন্তব্যগুলিতে @ হান্স ওলসন উল্লিখিত হিসাবে। এই সমস্যাটির বিষয়ে আমার সাম্প্রতিকতম পদ্ধতির মধ্যে উল্লিখিতগুলির মতো একই নিয়মের একটি সেট বিকাশ করা এবং একটি প্রজন্মের অ্যালগরিদমে তাদের নিয়োগ করা হয়েছে।
বিধি যেমন:
কখনও কোনও পদক্ষেপের বিপরীতে যাবেন না। 1-> 0 থেকে যান 0-> 1 (কোনও অর্থবোধ করে না)
টানা কখনও টুকরো টানা দু'বার নাও। 0 -> 1 থেকে 1 -> 3 থেকে কখনও সরাবেন না
স্ট্যাকস [এক্স] থেকে স্ট্যাক [ওয়াই] এর দিকে কিছুটা সরানো দেওয়া হয়েছে, তারপরে কিছুসংখ্যক পদক্ষেপ, তারপর স্ট্যাকস [ওয়াই] থেকে স্ট্যাকস [জেড] তে সরানো, যদি স্ট্যাকগুলি [জেড] একই অবস্থায় থাকে তবে সরানো যখন স্ট্যাকস [এক্স] থেকে স্ট্যাকের দিকে [ওয়াই] ঘটেছে, স্ট্যাকগুলি [এক্স] থেকে সরাসরি স্ট্যাকের দিকে সরিয়ে [মুছে ফেলা] [মুছে ফেলা]
বর্তমানে, আমি যথেষ্ট নিয়ম তৈরির প্রয়াস নিয়ে এই সমস্যাটির কাছে পৌঁছে যাচ্ছি যে এটি "বৈধ" পদক্ষেপের সংখ্যাকে ন্যূনতম করে দেয়, যাতে জেনারাল অ্যালগরিদম ব্যবহার করে কোনও উত্তর গণনা করা যায়। যদি কেউ অতিরিক্ত নিয়ম সম্পর্কে চিন্তা করতে পারে তবে আমি তাদের মন্তব্যগুলিতে শুনতে আগ্রহী।
হালনাগাদ
@ রুটটিউর উত্তরের জন্য ধন্যবাদ আমার কিছুটা ব্রেকথ্রু হয়েছিল, যা আমি এখানে রূপরেখা করব।
যুগান্তকারী
লক্ষ্যটির উচ্চতা নির্ধারণ করুন কারণ লক্ষ্য টুকরোটি অবশ্যই গন্তব্য স্ট্যাকের মধ্যে স্থাপন করতে হবে।
যখনই কোনও গোলের টুকরো সূচক <= স্ট্যাক_ উচ্চতা - গোলের উচ্চতায় স্থাপন করা হয়, ক্লিয়ার_পাথ () পদ্ধতির মাধ্যমে সর্বদা বিজয়ের সংক্ষিপ্ত পথ হবে।
Let S represent some solid Piece.আই ই
Stacks = [ [R, R, G], [G, G, R], [-, -, -] ]
Goal = Stacks[0][2] = R
Goal Height = 2.
Stack Height - Goal Height = 0এমন কিছু স্ট্যাক দেওয়া stack[0] = R, গেমটি জিতেছে।
GOAL
[ [ (S | -), (S | -), (S | -) ], [R, S, S], [(S | - ), (S | -), (S | -)] ]যেহেতু এটি জানা যায় যে এগুলি সর্বদা কমপক্ষে স্ট্যাক_ উচ্চতা ফাঁকা স্থান উপলব্ধ, তাই সবচেয়ে খারাপ সম্ভাব্য কেসটি হ'ল:
[ [ S, S, !Goal ], [R, S, S], [-, -, -]যেহেতু আমরা জানি গোলের পিসটি লক্ষ্য গন্ত্রে থাকতে পারে না বা খেলাটি জিততে পারে না। এক্ষেত্রে ন্যূনতম সংখ্যক মুভগুলির প্রয়োজনীয় পদক্ষেপগুলি হবে:
(0, 2), (0, 2), (0, 2), (1, 0)
Stacks = [ [R, G, G], [-, R, R], [-, -, G] ]
Goal = Stack[0][1] = R
Stack Height - Goal Height = 1এমন কিছু স্ট্যাক দেওয়া stack[1] = R, গেমটি জিতেছে।
GOAL
[ [ (S | -), (S | -), S], [ (S | -), R, S], [(S | -), (S | -), (S | -)]আমরা জানি কমপক্ষে 3 টি ফাঁকা জায়গা উপলব্ধ আছে, তাই সবচেয়ে খারাপ সম্ভাব্য কেসটি হ'ল:
[ [ S, !Goal, S], [S, R, S], [ -, -, - ]এক্ষেত্রে ন্যূনতম সংখ্যাটি চালগুলি হবে:
(1, 2), (0, 2), (0, 2), (1, 0)এটি সব ক্ষেত্রে ধরে রাখবে।
সুতরাং, গোলের উচ্চতাতে বা ততোধিক গোলের টুকরো স্থাপনের জন্য প্রয়োজনীয় ন্যূনতম পদক্ষেপের সন্ধান করার ক্ষেত্রে সমস্যাটি হ্রাস পেয়েছে।
এটি সমস্যাটিকে ধারাবাহিক উপ-সমস্যার মধ্যে বিভক্ত করে:
গন্তব্য স্ট্যাকের যখন তার অ্যাক্সেসযোগ্য টুকরা থাকে! = লক্ষ্য টুকরা, সেই টুকরোটির জন্য কোনও বৈধ অবস্থান আছে কিনা তা নির্ধারণ করে, বা অন্য টুকরোগুলি অদলবদল করার সময় টুকরোটি সেখানে থাকা উচিত কিনা তা নির্ধারণ করে।
যখন গন্তব্য স্ট্যাকের তার অ্যাক্সেসযোগ্য টুকরা == লক্ষ্য টুকরা থাকে, এটি নির্ধারিত করে যে এটি প্রয়োজনীয় লক্ষ্য উচ্চতাতে সরিয়ে নেওয়া যেতে পারে এবং অথবা অন্যটি অদলবদল করার সময় টুকরোটি থাকা উচিত কিনা।
উপরের দুটি ক্ষেত্রে যখন অন্য টুকরোগুলি অদলবদল করা প্রয়োজন তখন লক্ষ্য টুকরোটি লক্ষ্য উচ্চতায় পৌঁছানো সম্ভব করার জন্য কোন টুকরোগুলি অদলবদল করতে হবে তা নির্ধারণ করে।
গন্তব্য স্ট্যাকের সর্বদা এর ক্ষেত্রে প্রথমে মূল্যায়ন করা উচিত।
আই ই
stacks = [ [-, R, G], [-, R, G], [-, R, G] ]
Goal = stacks[0][1] = Gলক্ষ্য স্ট্যাক চেক করা প্রথমে বাড়ে:
(0, 1), (0, 2), (1, 0), (2, 0) = 4 Movesলক্ষ্য স্ট্যাক উপেক্ষা:
(1, 0), (1, 2), (0, 1), (0, 1), (2, 0) = 5 Moves