প্রস্থ-প্রথম অনুসন্ধানে কীভাবে পথটি চিহ্নিত করা যায়?

Question

আপনি কীভাবে একটি প্রসারিত-প্রথম অনুসন্ধানের পথটি সনাক্ত করেন, যেমন নীচের উদাহরণে:

যদি কীটির সন্ধান করা হয় 11তবে 1 থেকে 11 এর সাথে সংযুক্ত সংক্ষিপ্ত তালিকাটি ফিরিয়ে দিন ।

[1, 4, 7, 11]

Comments

কেভিন বেকন আইন ভিত্তিক কয়েক মাস আগে আমি একটি বন্ধুকে সহায়তা করছিলাম এটি আসলে একটি পুরানো কার্য ছিল। আমার চূড়ান্ত সমাধানটি খুব ঝিমঝিম ছিল, আমি মূলত "রিওয়াইন্ড" এবং ব্যাকট্র্যাকের জন্য আরেকটি প্রস্থ-প্রথম অনুসন্ধান করেছি did এর চেয়ে ভাল সমাধান আমি খুঁজে পাচ্ছি না।

— ক্রিস্টোফার মার্কিয়েটা

চমৎকার। একজন ইঞ্জিনিয়ারের প্রশংসনীয় বৈশিষ্ট্য হওয়ার জন্য আরও ভাল উত্তর পাওয়ার প্রয়াসে আমি একটি পুরানো সমস্যার পুনর্বিবেচনা বিবেচনা করি। আপনার পড়াশুনা এবং ক্যারিয়ারে আমি আপনাকে শুভ কামনা করছি।

— পিটার রওয়েল

প্রশংসা করার জন্য ধন্যবাদ, আমি বিশ্বাস করি যদি আমি এখনই এটি শিখি না, তবে আবার একই সমস্যার মুখোমুখি হব।

— ক্রিস্টোফার মার্কিয়েটা 20'12

সম্ভাব্য সদৃশ কিভাবে ধর্ষকের-ফার্স্ট অনুসন্ধান ব্যবহার করে 2 নোডের মধ্যে পাথ পেতে?

— nbro

Answer 1

আপনার প্রথমে http://en.wikedia.org/wiki/Breadth-first_search দেখতে হবে ।

---

নীচে একটি দ্রুত বাস্তবায়ন দেওয়া আছে, যেখানে আমি পথের সারি উপস্থাপনের জন্য তালিকার একটি তালিকা ব্যবহার করেছি।

# graph is in adjacent list representation
graph = {
        '1': ['2', '3', '4'],
        '2': ['5', '6'],
        '5': ['9', '10'],
        '4': ['7', '8'],
        '7': ['11', '12']
        }

def bfs(graph, start, end):
    # maintain a queue of paths
    queue = []
    # push the first path into the queue
    queue.append([start])
    while queue:
        # get the first path from the queue
        path = queue.pop(0)
        # get the last node from the path
        node = path[-1]
        # path found
        if node == end:
            return path
        # enumerate all adjacent nodes, construct a new path and push it into the queue
        for adjacent in graph.get(node, []):
            new_path = list(path)
            new_path.append(adjacent)
            queue.append(new_path)

print bfs(graph, '1', '11')

---

আর একটি পদ্ধতি হ'ল প্রতিটি নোড থেকে তার পিতামাতার কাছে একটি ম্যাপিং বজায় রাখা এবং সংলগ্ন নোডটি পরিদর্শন করার সময়, তার পিতামাতার রেকর্ড করুন। অনুসন্ধান শেষ হয়ে গেলে, প্যারেন্ট ম্যাপিং অনুসারে কেবল ব্যাকট্র্যাস করুন।

graph = {
        '1': ['2', '3', '4'],
        '2': ['5', '6'],
        '5': ['9', '10'],
        '4': ['7', '8'],
        '7': ['11', '12']
        }

def backtrace(parent, start, end):
    path = [end]
    while path[-1] != start:
        path.append(parent[path[-1]])
    path.reverse()
    return path


def bfs(graph, start, end):
    parent = {}
    queue = []
    queue.append(start)
    while queue:
        node = queue.pop(0)
        if node == end:
            return backtrace(parent, start, end)
        for adjacent in graph.get(node, []):
            if node not in queue :
                parent[adjacent] = node # <<<<< record its parent 
                queue.append(adjacent)

print bfs(graph, '1', '11')

উপরের কোডগুলি কোনও চক্র নেই এমন ধারণার উপর ভিত্তি করে।

Comments

এটি দুর্দান্ত! আমার চিন্তার প্রক্রিয়াটি আমাকে এক ধরণের টেবিল বা ম্যাট্রিক্স তৈরিতে বিশ্বাস করতে পরিচালিত করে, গ্রাফগুলি সম্পর্কে আমার এখনও শিখতে হবে না। ধন্যবাদ.

— ক্রিস্টোফার মার্কিয়েতা

আমি এটি ব্যাক ট্রেসিং পদ্ধতির ব্যবহার করার চেষ্টাও করেছি যদিও এটি আরও পরিষ্কার। আপনি যদি কেবল সূচনা এবং শেষটি জানেন তবে এর মধ্যে কোনও নোড নেই তবে গ্রাফ তৈরি করা কি সম্ভব? অথবা গ্রাফ ছাড়াও অন্য পদ্ধতির?

— ক্রিস্টোফার মার্কিয়েতা

@ ক্রিস্টোফর্ম আমি আপনার প্রশ্নটি বুঝতে ব্যর্থ হয়েছি :(

— কিয়াও

প্রথম অ্যালগরিদমটি কী এমনভাবে খাপ খাইয়ে নেওয়া সম্ভব যাতে এটি 1 থেকে 11 পর্যন্ত সমস্ত পথ ফেরত দেবে (একাধিকটি রয়েছে বলে ধরে নেওয়া)?

— মারিয়া ইনেস পরনসারি

এটি তালিকার পরিবর্তে কালেকশন.ডেক ব্যবহার করার পরামর্শ দেওয়া হচ্ছে। list.pop (0) এর জটিলতা হ'ল O (n), যখন deque.popleft () ও (1)

— ওমর_0x80

Answer 2

আমি কিয়াওর প্রথম উত্তরটি খুব পছন্দ করেছি! এখানে কেবল অনুপস্থিত জিনিসটি দেখা হয়েছে ভার্টেক্সগুলি চিহ্নিত করা হিসাবে।

কেন আমাদের এটি করা দরকার?
অনুমান করা যাক যে নোড ১১ থেকে আরও একটি নোড 13 সংযুক্ত রয়েছে। এখন আমাদের লক্ষ্য নোড 13 খুঁজে পাওয়া।
কিছুটা রান করার পরে কাতাকে এইরকম দেখাবে:

[[1, 2, 6], [1, 3, 10], [1, 4, 7], [1, 4, 8], [1, 2, 5, 9], [1, 2, 5, 10]]

মনে রাখবেন যে নোড নম্বর সহ TWO পাথ রয়েছে শেষে।
যার অর্থ হ'ল নোড নম্বর থেকে পাথগুলি দু'বার পরীক্ষা করা হবে। এই ক্ষেত্রে এটি এত খারাপ দেখাচ্ছে না কারণ নোড নম্বর 10 এর কোনও বাচ্চা নেই .. তবে এটি সত্যই খারাপ হতে পারে (এমনকি আমরা এখানে কোনও কারণ ছাড়াই সেই নোডটি দুবার পরীক্ষা করব ..)
নোড নম্বর 13 এ নেই এই পাথগুলি যাতে প্রোগ্রামটি শেষ পর্যন্ত 10 নোড সহ দ্বিতীয় পথে পৌঁছানোর আগে ফিরে না আসে ... এবং আমরা এটি পুনরায় পরীক্ষা করব ..

আমরা যে সমস্ত অনুপস্থিত তা হ'ল পরিদর্শন করা নোডগুলি চিহ্নিত করার জন্য এবং সেগুলি আবার চেক না করার জন্য একটি সেট ...
পরিবর্তনের পরে এটি কিয়াও কোড:

graph = {
    1: [2, 3, 4],
    2: [5, 6],
    3: [10],
    4: [7, 8],
    5: [9, 10],
    7: [11, 12],
    11: [13]
}


def bfs(graph_to_search, start, end):
    queue = [[start]]
    visited = set()

    while queue:
        # Gets the first path in the queue
        path = queue.pop(0)

        # Gets the last node in the path
        vertex = path[-1]

        # Checks if we got to the end
        if vertex == end:
            return path
        # We check if the current node is already in the visited nodes set in order not to recheck it
        elif vertex not in visited:
            # enumerate all adjacent nodes, construct a new path and push it into the queue
            for current_neighbour in graph_to_search.get(vertex, []):
                new_path = list(path)
                new_path.append(current_neighbour)
                queue.append(new_path)

            # Mark the vertex as visited
            visited.add(vertex)


print bfs(graph, 1, 13)

প্রোগ্রামটির আউটপুট হবে:

[1, 4, 7, 11, 13]

আনইনক্রেসারি পুনরায় পরীক্ষা না করে ..

Comments

এটা ব্যবহার করা সহায়ক হতে পারে collections.dequeজন্য queuelist.pop যেমন (0) বহন করতে O(n)মেমরির আন্দোলন। এছাড়াও, উত্তরসূরির স্বার্থে, আপনি যদি ডিএফএস করতে চান path = queue.pop()তবে চলকটি queueআসলে এর মতো কাজ করে stack।

— সুধি

Answer 3

খুব সহজ কোড। আপনি যখনই কোনও নোড আবিষ্কার করবেন তখন আপনি পাথ সংযোজন করতে থাকবেন।

graph = {
         'A': set(['B', 'C']),
         'B': set(['A', 'D', 'E']),
         'C': set(['A', 'F']),
         'D': set(['B']),
         'E': set(['B', 'F']),
         'F': set(['C', 'E'])
         }
def retunShortestPath(graph, start, end):

    queue = [(start,[start])]
    visited = set()

    while queue:
        vertex, path = queue.pop(0)
        visited.add(vertex)
        for node in graph[vertex]:
            if node == end:
                return path + [end]
            else:
                if node not in visited:
                    visited.add(node)
                    queue.append((node, path + [node]))

Comments

আমি অন্যান্য কোডের তুলনায় আপনার কোডটি খুব পঠনযোগ্য find আপনাকে অনেক ধন্যবাদ!

— মিটকো রুসেভ

Answer 4

আমি ভেবেছিলাম আমি মজাদার জন্য এটি কোড চেষ্টা করব:

graph = {
        '1': ['2', '3', '4'],
        '2': ['5', '6'],
        '5': ['9', '10'],
        '4': ['7', '8'],
        '7': ['11', '12']
        }

def bfs(graph, forefront, end):
    # assumes no cycles

    next_forefront = [(node, path + ',' + node) for i, path in forefront if i in graph for node in graph[i]]

    for node,path in next_forefront:
        if node==end:
            return path
    else:
        return bfs(graph,next_forefront,end)

print bfs(graph,[('1','1')],'11')

# >>>
# 1, 4, 7, 11

আপনি যদি চক্র চান তবে আপনি এটি যুক্ত করতে পারেন:

for i, j in for_front: # allow cycles, add this code
    if i in graph:
        del graph[i]

Comments

পরের_ফরফ_ফ্রন্টটি তৈরি করার পরে। প্রশ্নে একটি অনুসরণ, যদি গ্রাফটিতে লুপ থাকে? উদাহরণস্বরূপ নোড 1 যদি আবার একটি প্রান্তটি আবার যুক্ত হয় তবে? গ্রাফের দুটি নোডের মধ্যে একাধিক প্রান্ত থাকলে কী হবে?

— রবার্ট রাজা

Answer 5

আমি @ কিয়াওর প্রথম উত্তর এবং @ বা এর যোগ উভয়ই পছন্দ করি। কিছুটা কম প্রক্রিয়াজাত করার স্বার্থে আমি ওর এর উত্তর যুক্ত করতে চাই।

@ বা এর উত্তর পরিদর্শন করা নোডের ট্র্যাক করা দুর্দান্ত। আমরা বর্তমানে প্রোগ্রামটি যত তাড়াতাড়ি বাইরে বেরিয়ে আসার অনুমতি দিতে পারি। লুপের জন্য কোনও সময়ে লসটি current_neighbourহতে endহবে এবং এটির পরে একবারে সংক্ষিপ্ততম পথটি খুঁজে পাওয়া যায় এবং প্রোগ্রামটি ফিরে আসতে পারে।

আমি পদ্ধতিটি অনুসরণ হিসাবে পরিবর্তন করব, লুপের জন্য নিবিড় মনোযোগ দিন

graph = {
1: [2, 3, 4],
2: [5, 6],
3: [10],
4: [7, 8],
5: [9, 10],
7: [11, 12],
11: [13]
}


    def bfs(graph_to_search, start, end):
        queue = [[start]]
        visited = set()

    while queue:
        # Gets the first path in the queue
        path = queue.pop(0)

        # Gets the last node in the path
        vertex = path[-1]

        # Checks if we got to the end
        if vertex == end:
            return path
        # We check if the current node is already in the visited nodes set in order not to recheck it
        elif vertex not in visited:
            # enumerate all adjacent nodes, construct a new path and push it into the queue
            for current_neighbour in graph_to_search.get(vertex, []):
                new_path = list(path)
                new_path.append(current_neighbour)
                queue.append(new_path)

                #No need to visit other neighbour. Return at once
                if current_neighbour == end
                    return new_path;

            # Mark the vertex as visited
            visited.add(vertex)


print bfs(graph, 1, 13)

আউটপুট এবং অন্যান্য সমস্ত জিনিস একই হবে। তবে কোডটি প্রক্রিয়া করতে কম সময় নিবে। এটি বৃহত্তর গ্রাফগুলিতে বিশেষভাবে কার্যকর। আমি আশা করি এটি ভবিষ্যতে কাউকে সহায়তা করবে।