সংক্ষিপ্ত পথটি অনুসন্ধান করার সময় একটি প্রস্থ-প্রথম অনুসন্ধান কীভাবে কাজ করে?

Question

আমি কিছু গবেষণা করেছি এবং আমি মনে করি এই অ্যালগরিদমের একটি ছোট অংশ অনুপস্থিত। আমি বুঝতে পারি যে একটি ব্রেডথ-ফার্স্ট অনুসন্ধান কীভাবে কাজ করে, তবে আমি বুঝতে পারি না যে এটি কীভাবে আমাকে নির্দিষ্ট পথে নিয়ে যাবে, কেবলমাত্র প্রতিটি ব্যক্তিগত নোড কোথায় যেতে পারে তা আমাকে বলার বিপরীতে। আমার ধারণা আমি আমার বিভ্রান্তিকে ব্যাখ্যা করার সবচেয়ে সহজ উপায়টি একটি উদাহরণ প্রদান করা:

সুতরাং উদাহরণস্বরূপ, আসুন আমি বলি যে আমার মতো গ্রাফ রয়েছে:

এবং আমার লক্ষ্যটি এ থেকে ই পৌঁছানো (সমস্ত প্রান্ত অপ্রকাশিত)।

আমি এ থেকে শুরু করি কারণ এটি আমার উত্স। আমি A সারি করি, তারপরে তত্ক্ষণাত A কে চিহ্নিত করিয়া অনুসন্ধান করি। এটি বি এবং ডি উত্পাদন করে, কারণ এ বি এবং ডি এর সাথে সংযুক্ত রয়েছে আমি এইভাবে বি এবং ডি উভয়কেই সারি করি I

আমি বিটিকে চিহ্নিত করেছি এবং এটি সন্ধান করেছি এবং দেখতে পাচ্ছি যে এটি A (ইতিমধ্যে অন্বেষণকৃত) এবং সি এর দিকে নিয়ে যায়, সুতরাং আমি সিটিকে সারি করি এবং আমি ডিটিকে সন্ধান করি এবং এটি আমার লক্ষ্য লক্ষ্য করে to আমি তখন সিটিকে সরিয়েছি এবং দেখতে পাচ্ছি যে এটি আমার লক্ষ্যও ই নিয়ে যায়।

আমি যৌক্তিকভাবে জানি যে দ্রুততম পাথটি A-> D-> E, তবে আমি নিশ্চিত নই যে প্রস্থের প্রথম অনুসন্ধানটি ঠিক কীভাবে সহায়তা করে - আমার কীভাবে পাথ রেকর্ডিং করা উচিত যখন আমি শেষ করি, ফলাফলগুলি বিশ্লেষণ করে দেখতে পারি যে সবচেয়ে দীর্ঘতম পথটি-> ডি-> ই?

এছাড়াও, নোট করুন যে আমি আসলে একটি গাছ ব্যবহার করছি না, সুতরাং কোনও "পিতামাতা" নোড নেই, কেবল শিশু।

Comments

"এছাড়াও, নোট করুন যে আমি আসলে একটি গাছ ব্যবহার করছি না, সুতরাং কোনও" পিতামাতা "নোড নেই, কেবলমাত্র শিশুরা" - ভাল আপনাকে অবশ্যই পিতামাতাকে কোথাও সংরক্ষণ করতে হবে। ডিএফএসের জন্য আপনি কল স্ট্যাকের মাধ্যমে অপ্রত্যক্ষভাবে এটি করছেন, বিএফএসের জন্য আপনাকে এটি স্পষ্টভাবে করতে হবে। এটি সম্পর্কে আপনি যা করতে পারেন তা কিছুই আমি ভয় করি :)

— ভু

Answer 1

প্রযুক্তিগতভাবে, প্রস্থ-প্রথম অনুসন্ধান (বিএফএস) নিজেই আপনাকে সবচেয়ে সংক্ষিপ্ত পথটি খুঁজে পেতে দেয় না, কারণ বিএফএস সবচেয়ে দীর্ঘতম পথটি সন্ধান করছে না: বিএফএস একটি গ্রাফ অনুসন্ধানের কৌশল বর্ণনা করে, তবে এটি আপনাকে বলছে না যে আপনাকে অবশ্যই অনুসন্ধান করতে হবে বিশেষভাবে কিছু।

আপনাকে একক উত্সের সংক্ষিপ্ততম পথগুলি খুঁজে পেতে দেয়ায় ডিজকস্ট্রার অ্যালগরিদম বিএফএসকে রূপান্তর করে।

উত্স থেকে নোডের সংক্ষিপ্ততম পথটি পুনরুদ্ধার করার জন্য, আপনাকে গ্রাফের প্রতিটি নোডের জন্য দুটি আইটেম বজায় রাখতে হবে: এর বর্তমান সংক্ষিপ্ততম দূরত্ব এবং সংক্ষিপ্ত পথে পূর্ববর্তী নোড। প্রাথমিকভাবে সমস্ত দূরত্ব অনন্তকে সেট করা আছে, এবং সমস্ত পূর্বসূরীদের খালি সেট করা আছে। আপনার উদাহরণে, আপনি এ এর ​​দূরত্ব শূন্যতে সেট করেছেন এবং তারপরে বিএফএসের সাথে এগিয়ে যান। প্রতিটি পদক্ষেপে আপনি পরীক্ষা করে দেখুন যে আপনি কোনও বংশধরের দূরত্ব উন্নত করতে পারবেন কিনা, অর্থাত্ পূর্বসূরীর উত্স থেকে দূরত্ব এবং আপনি যে প্রান্তটি সন্ধান করছেন তার দৈর্ঘ্য প্রশ্নের নোডের বর্তমান সেরা দূরত্বের চেয়ে কম নয় is আপনি যদি দূরত্বটি উন্নতি করতে পারেন তবে নতুন সংক্ষিপ্ততম পথটি নির্ধারণ করুন এবং সেই পথটি অর্জন করা পূর্বসূরীর কথা মনে করুন। যখন বিএফএসের সারিটি খালি থাকে, একটি নোড বাছুন (আপনার উদাহরণস্বরূপ এটি ই) এবং তার পূর্বসূরীদের মূলের দিকে ফিরে যান।

এটি যদি কিছুটা বিভ্রান্তিকর মনে হয় তবে উইকিপিডিয়ায় বিষয়টিতে একটি দুর্দান্ত সিউডোকোড বিভাগ রয়েছে।

Comments

ধন্যবাদ! আমি পূর্বে সিউডোকোডটি পড়েছি কিন্তু এটি বুঝতে অক্ষম ছিলাম, আপনার ব্যাখ্যাটি এটি আমার জন্য ক্লিক করেছে

— জ্যাক

ভবিষ্যতে এই পোস্টটি দেখার জন্য আমি নিম্নলিখিত নোটটি তৈরি করতে চাই: প্রান্তগুলি যদি অপ্রকাশিত থাকে তবে প্রতিটি নোডের জন্য "বর্তমানের সংক্ষিপ্ততম দূরত্ব" সংরক্ষণ করার দরকার নেই। যে সমস্ত সঞ্চয় করতে হবে এটি হ'ল প্রতিটি নোডের জন্য পিতামাতা। সুতরাং, আপনি কোনও নোড পরীক্ষা করছেন এবং এর উত্তরসূরিদের সমস্ত সন্ধান করছেন, কেবল সেই নোডগুলির পিতামাতাকে আপনি যে নোডটি পরীক্ষা করছেন তা সেট করুন (এটি তাদের "আবিষ্কার" হিসাবে চিহ্নিত করার দ্বিগুণ হবে)) যদি এই প্যারেন্ট পয়েন্টারটি NUL / nil / কিছুই না হয় যে কোনও নোডের জন্য এটির অর্থ হ'ল এটি এখনও বিএফএস দ্বারা আবিষ্কার করা যায় নি বা এটি উত্স / মূল নোড।

— শশাঙ্ক

@ শশাঙ্ক যদি আমরা দূরত্ব বজায় না রাখি তবে আমরা কীভাবে সবচেয়ে কম দূরত্ব জানব, দয়া করে আরও ব্যাখ্যা করুন।

— গৌরব শেগাল

@ গৌরভসেহগাল এই মন্তব্যটি অনাহত প্রান্তযুক্ত গ্রাফের জন্য। বিএফএস কেবলমাত্র তার রেডিয়াল-অনুসন্ধানের প্যাটার্নের কারণে সবচেয়ে কম দূরত্বটি খুঁজে পাবে যা শুরুর দিক থেকে তাদের দূরত্বের ভিত্তিতে নোডকে বিবেচনা করে।

— শশাঙ্ক

@ শশাঙ্কের মন্তব্যের পাঠকদের জন্য একটি পরামর্শ: অপরিচ্ছন্ন এবং অভিন্ন ওজনযুক্ত (যেমন সমস্ত প্রান্তের ওজন = 5) সমান।

— TWiStErRob

Answer 2

উপরে উল্লিখিত হিসাবে, বিএফএস কেবল গ্রাফের মধ্যে সবচেয়ে সংক্ষিপ্ততম পথ খুঁজে পেতে ব্যবহার করা যেতে পারে যদি:

1. কোনও লুপ নেই

2. সমস্ত প্রান্ত একই ওজন বা ওজন নেই।

সংক্ষিপ্ততম পথটি সন্ধান করতে, আপনাকে যা করতে হবে তা হ'ল উত্স থেকে শুরু করে প্রস্থের প্রথম অনুসন্ধান করা এবং যখন আপনি আপনার গন্তব্য নোড পাবেন তখন থামাতে হবে। আপনার কেবলমাত্র অতিরিক্ত কাজটি করতে হবে একটি অ্যারে পূর্ববর্তী [n] যা দেখা প্রতিটি নোডের জন্য পূর্ববর্তী নোড সংরক্ষণ করবে। উত্সের পূর্ববর্তীটি নাল হতে পারে।

পাথটি মুদ্রণের জন্য, উত্স থেকে পূর্বের [] অ্যারের মাধ্যমে সরল লুপটি আপনি গন্তব্যে পৌঁছানো এবং নোডগুলি মুদ্রণ না করা পর্যন্ত। ডিএফএস অনুরূপ শর্তে গ্রাফের সবচেয়ে সংক্ষিপ্ততম পথটি খুঁজতে ব্যবহার করা যেতে পারে।

যাইহোক, যদি গ্রাফটি আরও জটিল হয় তবে ভারযুক্ত প্রান্ত এবং লুপগুলি থাকে তবে আমাদের বিএফএসের আরও পরিশীলিত সংস্করণ প্রয়োজন, যেমন ডিজজস্ট্রার অ্যালগরিদম।

Comments

ডিজকস্ট্র যদি না-ওজন হয় না তবে বেলম্যান ফোর আলগো যদি-আমাদের ওয়েট ব্যবহার করেন

— shaunak1111

বিএফএস কি দুটি নোডের মধ্যে সংক্ষিপ্ততম সমস্ত পথ খুঁজে পেতে কাজ করে?

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

@ জাভাপ্রোগ্রামার, এটি ঠিক নেই। অবিবাহিত চক্রাকার গ্রাফের মধ্যে সবচেয়ে ছোট পথ খুঁজে পেতে বিএফএস ব্যবহার করা যেতে পারে। যদি কোনও গ্রাফ অপ্রকাশিত থাকে, তবে লুপগুলি নির্বিশেষে এসপি-তে বিএফএস প্রয়োগ করা যেতে পারে।

— আন্দ্রেই কাইগোরোদভ

To print the path, simple loop through the previous[] array from source till you reach destination.তবে উত্সটির পূর্ববর্তীটি শূন্য। আমি মনে করি আপনি যা বলতে চেয়েছিলেন তা হল backtrace from destination using the previous array until you reach the source,।

— aandis

আপনি কেন বলেন যে ডিএফএস একই পরিস্থিতিতে কাজ করবে? নোডস স্টার্ট-> প্রান্ত থেকে ডিএফএসের পক্ষে কোনও নিরীহ বৃত্তাকার রাস্তা নেওয়া সম্ভব নয় এবং তাই আপনাকে এমন একটি পথ দেবে যা সংক্ষিপ্ততম নয়?

— জেমস ওয়েয়ারজবা

Answer 3

টিউটোরিয়াল থেকে এখানে

"এটির অত্যন্ত কার্যকর সম্পত্তি রয়েছে যে কোনও গ্রাফের সমস্ত প্রান্ত যদি অপ্রকাশিত (বা একই ওজন) হয় তবে প্রথমবার কোনও নোড পরিদর্শন করা হলে উত্স নোড থেকে সেই নোডের সবচেয়ে সংক্ষিপ্ত পথ"

Comments

এটি সরাসরি পৌঁছনীয় নোডের জন্য ভাল (1-> 2) (2 সরাসরি 1 থেকে পৌঁছেছে)। সরাসরি-পৌঁছনীয় নোডের জন্য আরও কাজ রয়েছে (1-> 2-> 3, 3 সরাসরি 1 থেকে পৌঁছায় না)। অবশ্যই এটি স্বতন্ত্রভাবে বিবেচনা করে সত্য, অর্থাত্ 1-> 2 & 2-> 3 স্বতন্ত্রতম পথগুলি।

— মনোহর রেড্ডি পোরেড্ডি

Answer 4

আমি 3 দিন নষ্ট করেছি
চূড়ান্তভাবে বিএফএস ব্যবহার করে সবচেয়ে কম দূরত্ব সন্ধানের
জন্য ব্যবহৃত একটি গ্রাফ প্রশ্নের সমাধান করেছি

অভিজ্ঞতা ভাগ করতে চান।

When the (undirected for me) graph has
fixed distance (1, 6, etc.) for edges

#1
We can use BFS to find shortest path simply by traversing it
then, if required, multiply with fixed distance (1, 6, etc.)

#2
As noted above
with BFS
the very 1st time an adjacent node is reached, it is shortest path

#3
It does not matter what queue you use
   deque/queue(c++) or
   your own queue implementation (in c language)
   A circular queue is unnecessary

#4
Number of elements required for queue is N+1 at most, which I used
(dint check if N works)
here, N is V, number of vertices.

#5
Wikipedia BFS will work, and is sufficient.
    https://en.wikipedia.org/wiki/Breadth-first_search#Pseudocode

আমি উপরের সমস্ত বিকল্পগুলি চেষ্টা করে 3 দিন হারিয়েছি, যাচাই-বাছাই করে পুনরায় যাচাই-বাছাই করে
তারা আবার সমস্যা নেই।
(অন্যান্য বিষয়গুলির সন্ধানের জন্য সময় ব্যয় করার চেষ্টা করুন, যদি আপনি উপরে 5 এর সাথে কোনও সমস্যা খুঁজে পান না)

---

নীচের মন্তব্য থেকে আরও ব্যাখ্যা :

      A
     /  \
  B       C
 /\       /\
D  E     F  G

ধরে নিন উপরের গ্রাফটি এ এর জন্য
নীচে চলে গেছে, সংলগ্নগুলি
বি এবং সি এর
জন্য বি, সংলগ্ন ডি এবং ই
সি এর জন্য, সংলগ্নগুলি এফ এবং জি

বলে, শুরু নোড হল এ

1. আপনি যখন A, to, B&C এ পৌঁছান তখন A থেকে B এবং C এর সবচেয়ে কম দূরত্ব 1

2. আপনি যখন ডি বা ই পৌঁছান, বি এর মাধ্যমে, এ & ডি এর সবচেয়ে কম দূরত্ব 2 (এ-> বি-> ডি) হয়

একইভাবে, এ-> ই 2 (এ-> বি-> ই)

এছাড়াও, এ-> এফ & এ-> জি 2 হয়

সুতরাং, এখন নোডগুলির মধ্যে 1 দূরত্বের পরিবর্তে, যদি এটি 6 হয় তবে উত্তরটি 6 টি দিয়ে গুণ করুন
,
যদি প্রতিটির মধ্যে দূরত্ব 1 হয় তবে A-> E 2 হয় (A-> B-> E = 1 + 1 )
যদি প্রত্যেকের মধ্যে দূরত্ব 6 হয় তবে এ-> ই 12 হয় (এ-> বি-> ই = 6 + 6)

হ্যাঁ, বিএফএস যে কোনও পথ নিতে পারে
তবে আমরা সমস্ত পাথের জন্য গণনা করছি

যদি আপনাকে এ থেকে জেডে যেতে হয়, তবে আমরা এ থেকে মধ্যবর্তী প্রথম দিকে সমস্ত পাথ ভ্রমণ করি এবং যেহেতু অনেকগুলি পথ থাকবে আমরা আমার অবধি সংক্ষিপ্ততম পথ বাদ দিই, তারপরে পরবর্তী নোডের সামনে আরও সংক্ষিপ্ত পথটি চালিয়ে যাই
যদি আবার আই থেকে জে পর্যন্ত একাধিক পাথ রয়েছে, আমরা কেবলমাত্র একটি সংক্ষিপ্ত
উদাহরণ
নিই , ধরে নিই,
এ -> আমার কাছে দূরত্ব রয়েছে 5
(STEP) ধরে নেওয়া, I -> J আমাদের একাধিক পথ রয়েছে, দূরত্বের 7 এবং 8, যেহেতু 7 সংক্ষিপ্ততম হয়
আমরা এ -> জে 5 হিসাবে গ্রহণ করি (এ-> আমি সবচেয়ে সংক্ষিপ্ত) + 8 (এখনই সংক্ষিপ্ততম) = 13
সুতরাং এ-> জে এখন 13 -
আমরা এখন পর্যন্ত জে -> কে এর উপরে (স্টেপ) পুনরাবৃত্তি করব, যতক্ষণ না আমরা পাব জেড

এই অংশটি 2 বা 3 বার পড়ুন এবং কাগজে আঁকুন, আপনি অবশ্যই যা বলছেন তা পাবেন, শুভকামনা

---

Comments

আপনি কি দয়া করে বিশদভাবে প্রথম সন্ধানের সাথে সংক্ষিপ্ততম পথটি কীভাবে পরিচালনা করবেন তা ব্যাখ্যা করতে পারেন। প্রথম প্রস্থের প্রথম অনুসন্ধানটি মূলত নোডের সন্ধান করে, উত্স নোড থেকে লক্ষ্য নোডের কোনও এন পাথ থাকতে পারে এবং বিএফএস কোনও পথ নিতে পারে। আপনি কিভাবে সেরা পথ নির্ধারণ করছেন?

— আন্ডারডগ

উপরের উত্তরে আমি 'আরও ব্যাখ্যা' অংশ যুক্ত করেছি, তা সন্তুষ্ট হলে আমাকে

— জানাবেন

আমি দেখছি আপনি ভারী গ্রাফে বিএফএস চালানোর চেষ্টা করছেন। দূরত্বের 7 এবং 8 আপনি 8 টি বেছে নিলেন কেন? কেন 7? 8 নোডের গন্তব্যে আরও প্রান্ত না থাকলে কী হবে? প্রবাহটি তখন 7 টি চয়ন করতে হবে।

— আন্ডারডগ

ভাল প্রশ্ন, উত্সাহিত, হ্যাঁ, আমরা ফেলে দিচ্ছি না, আমরা গন্তব্যে পৌঁছানো অবধি সমস্ত সংলগ্ন নোডের ট্র্যাক রাখি। বিএফএস কেবল তখনই কাজ করবে যখন সমস্ত 7 বা সমস্ত 8 এর মতো কেবল ধ্রুবক দূরত্ব থাকবে 8 8. আমি একটি জেনেরিক দিয়েছি যার & ও ৮ রয়েছে যা ডাইজকস্ট্রার অ্যালগরিদম হিসাবেও পরিচিত।

— মনোহর রেড্ডি পোরেডি

দুঃখিত, নিশ্চিত না আপনি কি বলতে চাইছেন, দেখুন en.wikipedia.org/wiki/Dijkstra's_algorithm

— মনোহর রেড্ডি Poreddy

Answer 5

Acheron55 উত্তরের উপর ভিত্তি করে আমি এখানে একটি সম্ভাব্য বাস্তবায়ন পোস্ট করেছি ।
এটির সংক্ষিপ্তসার এখানে দেওয়া হল:

আপনাকে যা করতে হবে তা হ'ল লক্ষ্যটি যে পথে পৌঁছেছে তার ট্র্যাক রাখা। এটি করার একটি সহজ উপায় হ'ল Queueনোডের পরিবর্তে কোনও নোডে পৌঁছানোর জন্য ব্যবহৃত পুরো পথটি ধাক্কা ।
এটি করার সুবিধাটি হ'ল লক্ষ্যটি কাতারে পৌঁছে গেলে এটি পৌঁছানোর জন্য ব্যবহৃত পথটি ধরে রাখে।
এটি চক্রীয় গ্রাফগুলিতেও প্রযোজ্য, যেখানে নোডের একাধিক পিতামাতারা থাকতে পারে।

Answer 6

কিছু সময় নিষ্ক্রিয়তার পরে এই থ্রেডে দেখা হচ্ছে, কিন্তু আমি এর পুরো উত্তর দেখতে পাচ্ছি না, এখানে আমার দুটি সেন্ট।

চওড়া-প্রথম অনুসন্ধান সর্বদা একটি অপ্রকাশিত গ্রাফের সবচেয়ে সংক্ষিপ্ত পথটি খুঁজে পাবে। গ্রাফটি চক্রীয় বা অ্যাসাইক্লিক হতে পারে।

সিউডোকোডের জন্য নীচে দেখুন। এই সিউডোকোড ধরে নিয়েছে যে আপনি বিএফএস বাস্তবায়নের জন্য একটি সারি ব্যবহার করছেন। এটিও ধরে নিয়েছে যে আপনি পরিদর্শন হিসাবে উল্লম্ব চিহ্নিত করতে পারেন, এবং প্রতিটি শীর্ষবিন্দু একটি দূরত্বের প্যারামিটার সঞ্চয় করে যা অনন্তের দিকে শুরু হয়।

mark all vertices as unvisited
set the distance value of all vertices to infinity
set the distance value of the start vertex to 0
push the start vertex on the queue
while(queue is not empty)   
    dequeue one vertex (we’ll call it x) off of the queue
    if the value of x is the value of the end vertex: 
        return the distance value of x
    otherwise, if x is not marked as visited:
        mark it as visited
        for all of the unmarked children of x:
            set their distance values to be the distance of x + 1
            enqueue them to the queue
if here: there is no path connecting the vertices

নোট করুন যে এই পদ্ধতিটি ভারিত গ্রাফগুলির জন্য কাজ করে না - তার জন্য, ডিজকস্ট্রার অ্যালগরিদম দেখুন।

Answer 7

নিম্নলিখিত সমাধানটি সমস্ত পরীক্ষার ক্ষেত্রে কাজ করে।

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

   public static void main(String[] args)
        {
            Scanner sc = new Scanner(System.in);

            int testCases = sc.nextInt();

            for (int i = 0; i < testCases; i++)
            {
                int totalNodes = sc.nextInt();
                int totalEdges = sc.nextInt();

                Map<Integer, List<Integer>> adjacencyList = new HashMap<Integer, List<Integer>>();

                for (int j = 0; j < totalEdges; j++)
                {
                    int src = sc.nextInt();
                    int dest = sc.nextInt();

                    if (adjacencyList.get(src) == null)
                    {
                        List<Integer> neighbours = new ArrayList<Integer>();
                        neighbours.add(dest);
                        adjacencyList.put(src, neighbours);
                    } else
                    {
                        List<Integer> neighbours = adjacencyList.get(src);
                        neighbours.add(dest);
                        adjacencyList.put(src, neighbours);
                    }


                    if (adjacencyList.get(dest) == null)
                    {
                        List<Integer> neighbours = new ArrayList<Integer>();
                        neighbours.add(src);
                        adjacencyList.put(dest, neighbours);
                    } else
                    {
                        List<Integer> neighbours = adjacencyList.get(dest);
                        neighbours.add(src);
                        adjacencyList.put(dest, neighbours);
                    }
                }

                int start = sc.nextInt();

                Queue<Integer> queue = new LinkedList<>();

                queue.add(start);

                int[] costs = new int[totalNodes + 1];

                Arrays.fill(costs, 0);

                costs[start] = 0;

                Map<String, Integer> visited = new HashMap<String, Integer>();

                while (!queue.isEmpty())
                {
                    int node = queue.remove();

                    if(visited.get(node +"") != null)
                    {
                        continue;
                    }

                    visited.put(node + "", 1);

                    int nodeCost = costs[node];

                    List<Integer> children = adjacencyList.get(node);

                    if (children != null)
                    {
                        for (Integer child : children)
                        {
                            int total = nodeCost + 6;
                            String key = child + "";

                            if (visited.get(key) == null)
                            {
                                queue.add(child);

                                if (costs[child] == 0)
                                {
                                    costs[child] = total;
                                } else if (costs[child] > total)
                                {
                                    costs[child] = total;
                                }
                            }
                        }
                    }
                }

                for (int k = 1; k <= totalNodes; k++)
                {
                    if (k == start)
                    {
                        continue;
                    }

                    System.out.print(costs[k] == 0 ? -1 : costs[k]);
                    System.out.print(" ");
                }
                System.out.println();
            }
        }
}

Comments

প্রশ্নের উত্তর না দেওয়ার জন্য অবনমিত। কেবলমাত্র একটি কোড স্নিপেট পেস্ট করা SO এ কাজ করবে না।

— habষভ অগ্রহরি