সমস্ত দ্বীপ সংযোগ করতে সর্বনিম্ন ব্যয় কত?

Question 1

সাইজের এন x এম গ্রিড রয়েছে । কিছু কোষ দ্বীপপুঞ্জকে '0' দ্বারা চিহ্নিত করা হয় এবং অন্যগুলি জল হয় । প্রতিটি কক্ষের একটি সেল রয়েছে যার উপরে সেলে তৈরি সেতুর দাম বোঝানো হয়। আপনাকে সর্বনিম্ন ব্যয় খুঁজতে হবে যার জন্য সমস্ত দ্বীপগুলি সংযুক্ত হতে পারে। কোনও কক্ষ অন্য একটি কক্ষের সাথে সংযুক্ত থাকে যদি এটি একটি প্রান্ত বা একটি শীর্ষবিন্দু ভাগ করে।

এই সমস্যাটি সমাধান করতে কোন অ্যালগরিদম ব্যবহার করা যেতে পারে? এন, এম এর মান খুব কম হলে একটি নিষ্ঠুর বল পদক্ষেপ হিসাবে কী ব্যবহার করা যেতে পারে, এনএক্সএম <= 100 বলুন?

উদাহরণ : প্রদত্ত চিত্রটিতে, সবুজ কোষগুলি দ্বীপগুলি নির্দেশ করে, নীল কোষগুলি জল নির্দেশ করে এবং হালকা নীল কোষগুলি সেতুগুলিকে নির্দেশ করে যার উপর একটি সেতু করা উচিত। সুতরাং নিম্নলিখিত চিত্রের জন্য, উত্তর 17 হবে ।

প্রথমদিকে আমি সমস্ত দ্বীপগুলিকে নোড হিসাবে চিহ্নিত করার এবং প্রতিটি জোড় দ্বীপকে একটি সংক্ষিপ্ত সেতু দ্বারা সংযুক্ত করার কথা ভেবেছিলাম। তারপরে সমস্যাটি ন্যূনতম বিস্তৃত গাছে কমে যেতে পারে, তবে এই পদ্ধতির সাথে আমি সেই ক্ষেত্রেটি মিস করেছি যেখানে প্রান্তগুলি ওভারল্যাপিং করছে are উদাহরণ হিসেবে বলা যায় , নীচের চিত্রটি যে কোনো দুটি দ্বীপ মধ্যে সবচেয়ে কম দূরত্ব 7 (হলুদ চিহ্নিত), তাই নূন্যতম Spanning গাছ উত্তর ব্যবহার করে হবে 14 , কিন্তু উত্তর হওয়া উচিত 11 (হাল্কা নীল চিহ্নিত)।

ইমেজ 2

Question 2

এই সমস্যাটি দেখতে, আমি একটি পূর্ণসংখ্যা প্রোগ্রামিং ফ্রেমওয়ার্ক ব্যবহার করব এবং সিদ্ধান্ত ভেরিয়েবলের তিনটি সেট নির্ধারণ করব:

x_ij : আমরা জলের অবস্থান (i, j) এ ব্রিজ তৈরি করি কিনা এর জন্য একটি বাইনারি সূচক পরিবর্তনশীল।
y_ijbcn : জলের অবস্থান (i, j) দ্বীপ খ সাথে দ্বীপকে সংযোগকারী n ^ ম অবস্থান যা কিনা তার জন্য একটি বাইনারি সূচক।
l_bc : দ্বীপপুঞ্জের বি এবং সি সরাসরি যুক্ত রয়েছে কিনা এর জন্য একটি বাইনারি সূচক পরিবর্তনশীল (ওরফে আপনি কেবল ব্রিজ স্কোয়ারে বি থেকে সি পর্যন্ত হাঁটতে পারবেন)।

ব্রিজ বিল্ডিংয়ের জন্য সি_আইজি ব্যয় হয়, হ্রাস করার উদ্দেশ্যগত মানটি sum_ij c_ij * x_ij। আমাদের মডেলটিতে নিম্নলিখিত সীমাবদ্ধতাগুলি যুক্ত করতে হবে:

আমাদের নিশ্চিত করতে হবে y_ijbcn ভেরিয়েবল বৈধ কিনা। আমরা যদি সেখানে সেতু তৈরি করি তবে আমরা কেবলমাত্র জলের স্কোয়ারে পৌঁছে যেতে পারি, তাই y_ijbcn <= x_ijপ্রতিটি জলের অবস্থানের (i, j) জন্য। আরও, y_ijbc1যদি (i, j) দ্বীপ বি সীমানা না করে তবে অবশ্যই 0 এর সমান হতে হবে। অবশেষে, এন> 1 এর জন্য, y_ijbcnকেবলমাত্র যদি প্রতিবেশী জলের অবস্থানটি পদক্ষেপ এন -1 ব্যবহার করা হত। N(i, j)জলের স্কোয়ারগুলি প্রতিবেশী (i, j) হিসাবে সংজ্ঞায়িত করা, এটি সমান y_ijbcn <= sum_{(l, m) in N(i, j)} y_lmbc(n-1)।
আমাদের নিশ্চিত করতে হবে l_bc ভেরিয়েবলগুলি কেবলমাত্র খ এবং সি লিঙ্কযুক্ত থাকলে সেট করা আছে। যদি আমরা I(c)দ্বীপ সীমান্তবর্তী অবস্থানগুলি হিসাবে সংজ্ঞায়িত করি তবে এটি সম্পন্ন করা যেতে পারে l_bc <= sum_{(i, j) in I(c), n} y_ijbcn।
আমাদের নিশ্চিত করতে হবে যে সমস্ত দ্বীপ প্রত্যক্ষ বা পরোক্ষভাবে সংযুক্ত রয়েছে। এটি নিম্নলিখিত উপায়ে সম্পন্ন করা যেতে পারে: দ্বীপগুলির প্রতিটি অ-খালি যথাযথ উপসেট এসের জন্য, এস এর কমপক্ষে একটি দ্বীপ কমপক্ষে একটি দ্বীপের সাথে সংযুক্ত থাকে যা এস এর পরিপূরক হয়, যাকে আমরা এস 'বলব। সীমাবদ্ধতায়, আমরা আকারের প্রতিটি খালি খালি সেট এস এর জন্য সীমাবদ্ধতা যোগ করে এটি প্রয়োগ করতে পারি <= কে / 2 (যেখানে কে দ্বীপের সংখ্যা) sum_{b in S} sum_{c in S'} l_bc >= 1,।

কে দ্বীপপুঞ্জ, ডাব্লু জলের বর্গক্ষেত্র এবং সুনির্দিষ্ট সর্বাধিক পাথ দৈর্ঘ্যের এনগুলির ক্ষেত্রে সমস্যার জন্য, এটি O(K^2WN)ভেরিয়েবল এবং O(K^2WN + 2^K)সীমাবদ্ধতার সাথে একটি মিশ্র পূর্ণসংখ্যা প্রোগ্রামিং মডেল । স্পষ্টতই সমস্যাটির আকার বড় হওয়ার সাথে সাথে এটি অচল হয়ে উঠবে, তবে আপনি যে আকারের সেগুলি আকারের জন্য এটি সমাধানযোগ্য হতে পারে। স্কেলাবিলিটির ধারণাটি পেতে, আমি সজ্জা প্যাকেজটি ব্যবহার করে অজগরটিতে এটি প্রয়োগ করব। আসুন প্রথমে প্রশ্নটির নীচে 3 দ্বীপপুঞ্জের সাথে ছোট 7 x 9 মানচিত্র দিয়ে শুরু করি:

import itertools
import pulp
water = {(0, 2): 2.0, (0, 3): 1.0, (0, 4): 1.0, (0, 5): 1.0, (0, 6): 2.0,
         (1, 0): 2.0, (1, 1): 9.0, (1, 2): 1.0, (1, 3): 9.0, (1, 4): 9.0,
         (1, 5): 9.0, (1, 6): 1.0, (1, 7): 9.0, (1, 8): 2.0,
         (2, 0): 1.0, (2, 1): 9.0, (2, 2): 9.0, (2, 3): 1.0, (2, 4): 9.0,
         (2, 5): 1.0, (2, 6): 9.0, (2, 7): 9.0, (2, 8): 1.0,
         (3, 0): 9.0, (3, 1): 1.0, (3, 2): 9.0, (3, 3): 9.0, (3, 4): 5.0,
         (3, 5): 9.0, (3, 6): 9.0, (3, 7): 1.0, (3, 8): 9.0,
         (4, 0): 9.0, (4, 1): 9.0, (4, 2): 1.0, (4, 3): 9.0, (4, 4): 1.0,
         (4, 5): 9.0, (4, 6): 1.0, (4, 7): 9.0, (4, 8): 9.0,
         (5, 0): 9.0, (5, 1): 9.0, (5, 2): 9.0, (5, 3): 2.0, (5, 4): 1.0,
         (5, 5): 2.0, (5, 6): 9.0, (5, 7): 9.0, (5, 8): 9.0,
         (6, 0): 9.0, (6, 1): 9.0, (6, 2): 9.0, (6, 6): 9.0, (6, 7): 9.0,
         (6, 8): 9.0}
islands = {0: [(0, 0), (0, 1)], 1: [(0, 7), (0, 8)], 2: [(6, 3), (6, 4), (6, 5)]}
N = 6

# Island borders
iborders = {}
for k in islands:
    iborders[k] = {}
    for i, j in islands[k]:
        for dx in [-1, 0, 1]:
            for dy in [-1, 0, 1]:
                if (i+dx, j+dy) in water:
                    iborders[k][(i+dx, j+dy)] = True

# Create models with specified variables
x = pulp.LpVariable.dicts("x", water.keys(), lowBound=0, upBound=1, cat=pulp.LpInteger)
pairs = [(b, c) for b in islands for c in islands if b < c]
yvals = []
for i, j in water:
    for b, c in pairs:
        for n in range(N):
            yvals.append((i, j, b, c, n))

y = pulp.LpVariable.dicts("y", yvals, lowBound=0, upBound=1)
l = pulp.LpVariable.dicts("l", pairs, lowBound=0, upBound=1)
mod = pulp.LpProblem("Islands", pulp.LpMinimize)

# Objective
mod += sum([water[k] * x[k] for k in water])

# Valid y
for k in yvals:
    i, j, b, c, n = k
    mod += y[k] <= x[(i, j)]
    if n == 0 and not (i, j) in iborders[b]:
        mod += y[k] == 0
    elif n > 0:
        mod += y[k] <= sum([y[(i+dx, j+dy, b, c, n-1)] for dx in [-1, 0, 1] for dy in [-1, 0, 1] if (i+dx, j+dy) in water])

# Valid l
for b, c in pairs:
    mod += l[(b, c)] <= sum([y[(i, j, B, C, n)] for i, j, B, C, n in yvals if (i, j) in iborders[c] and B==b and C==c])

# All islands connected (directly or indirectly)
ikeys = islands.keys()
for size in range(1, len(ikeys)/2+1):
    for S in itertools.combinations(ikeys, size):
        thisSubset = {m: True for m in S}
        Sprime = [m for m in ikeys if not m in thisSubset]
        mod += sum([l[(min(b, c), max(b, c))] for b in S for c in Sprime]) >= 1

# Solve and output
mod.solve()
for row in range(min([m[0] for m in water]), max([m[0] for m in water])+1):
    for col in range(min([m[1] for m in water]), max([m[1] for m in water])+1):
        if (row, col) in water:
            if x[(row, col)].value() > 0.999:
                print "B",
            else:
                print "-",
        else:
            print "I",
    print ""

সজ্জা প্যাকেজ (সিবিসি সলভার) থেকে ডিফল্ট সল্ভার ব্যবহার করে চালাতে 1.4 সেকেন্ড সময় লাগে এবং সঠিক সমাধানটি আউটপুট করে:

I I - - - - - I I 
- - B - - - B - - 
- - - B - B - - - 
- - - - B - - - - 
- - - - B - - - - 
- - - - B - - - - 
- - - I I I - - -

এরপরে, প্রশ্নের শীর্ষে পুরো সমস্যাটি বিবেচনা করুন, যা 7 টি দ্বীপযুক্ত 13 x 14 গ্রিড:

water = {(i, j): 1.0 for i in range(13) for j in range(14)}
islands = {0: [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)],
           1: [(9, 0), (9, 1), (10, 0), (10, 1), (10, 2), (11, 0), (11, 1),
               (11, 2), (12, 0)],
           2: [(0, 7), (0, 8), (1, 7), (1, 8), (2, 7)],
           3: [(7, 7), (8, 6), (8, 7), (8, 8), (9, 7)],
           4: [(0, 11), (0, 12), (0, 13), (1, 12)],
           5: [(4, 10), (4, 11), (5, 10), (5, 11)],
           6: [(11, 8), (11, 9), (11, 13), (12, 8), (12, 9), (12, 10), (12, 11),
               (12, 12), (12, 13)]}
for k in islands:
    for i, j in islands[k]:
        del water[(i, j)]

for i, j in [(10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12),
             (11, 7), (12, 7)]:
    water[(i, j)] = 20.0

N = 7

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

mod.solve(pulp.solvers.PULP_CBC_CMD(maxSeconds=120))

এটি উদ্দেশ্যগত মান 17 সহ একটি সমাধান দেয়:

I I - - - - - I I - - I I I 
I I - - - - - I I - - - I - 
I I - - - - - I - B - B - - 
- - B - - - B - - - B - - - 
- - - B - B - - - - I I - - 
- - - - B - - - - - I I - - 
- - - - - B - - - - - B - - 
- - - - - B - I - - - - B - 
- - - - B - I I I - - B - - 
I I - B - - - I - - - - B - 
I I I - - - - - - - - - - B 
I I I - - - - - I I - - - I 
I - - - - - - - I I I I I I

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

mod.solve(pulp.solvers.GUROBI(timeLimit=120))

এটি প্রকৃতপক্ষে অবজেক্টিভ ভ্যালু 16 এর সমাধান খুঁজে পায়, ওপি হাতের সাহায্যে খুঁজে পেতে সক্ষম হয়ে তার চেয়ে ভাল better

I I - - - - - I I - - I I I 
I I - - - - - I I - - - I - 
I I - - - - - I - B - B - - 
- - B - - - - - - - B - - - 
- - - B - - - - - - I I - - 
- - - - B - - - - - I I - - 
- - - - - B - - B B - - - - 
- - - - - B - I - - B - - - 
- - - - B - I I I - - B - - 
I I - B - - - I - - - - B - 
I I I - - - - - - - - - - B 
I I I - - - - - I I - - - I 
I - - - - - - - I I I I I I

Question 3

সিউডো-কোডে একটি হিংস্র শক্তি প্রয়োগ:

start with a horrible "best" answer
given an nxm map,
    try all 2^(n*m) combinations of bridge/no-bridge for each cell
        if the result is connected, and better than previous best, store it

return best

সি ++ এ এটি হিসাবে লেখা যেতে পারে

// map = linearized map; map[x*n + y] is the equivalent of map2d[y][x]
// nm = n*m
// bridged = true if bridge there, false if not. Also linearized
// nBridged = depth of recursion (= current bridge being considered)
// cost = total cost of bridges in 'bridged'
// best, bestCost = best answer so far. Initialized to "horrible"
void findBestBridges(char map[], int nm,
   bool bridged[], int nBridged, int cost, bool best[], int &bestCost) {
   if (nBridged == nm) {
      if (connected(map, nm, bridged) && cost < bestCost) {
          memcpy(best, bridged, nBridged);
          bestCost = best;
      }
      return;
   }
   if (map[nBridged] != 0) {
      // try with a bridge there
      bridged[nBridged] = true;
      cost += map[nBridged];

      // see how it turns out
      findBestBridges(map, nm, bridged, nBridged+1, cost, best, bestCost);         

      // remove bridge for further recursion
      bridged[nBridged] = false;
      cost -= map[nBridged];
   }
   // and try without a bridge there
   findBestBridges(map, nm, bridged, nBridged+1, cost, best, bestCost);
}

প্রথম কল করার পরে (আমি ধরে নিচ্ছি যে আপনি নিজের অনুলিপি সহজেই অনুলিপি করার জন্য আপনার 2 ডি মানচিত্রকে 1 ডি অ্যারে রূপান্তর করছেন), bestCostএতে উত্তরের উত্তরের ব্যয় bestথাকবে এবং এতে সেতুগুলির প্যাটার্ন থাকবে যা এতে পাওয়া যায়। এটি যদিও অত্যন্ত ধীর।

অপ্টিমাইজেশন:

একটি "ব্রিজ সীমা" ব্যবহার করে এবং সেতুগুলির সর্বাধিক সংখ্যা বৃদ্ধির জন্য অ্যালগরিদম চালিয়ে আপনি পুরো গাছটি অন্বেষণ না করে ন্যূনতম উত্তরগুলি পেতে পারেন। একটি 1-সেতুর উত্তর সন্ধান, যদি এটি বিদ্যমান থাকে তবে ও (2 ^ এনএম) এর পরিবর্তে ও (এনএম) হবে - একটি অত্যন্ত উন্নতি।
একবার আপনি অতিক্রম করার পরে আপনি অনুসন্ধানগুলি এড়াতে পারবেন (পুনরাবৃত্তি থামিয়ে; এটি "ছাঁটাই "ও বলা হয়) bestCost, কারণ এটি পরে দেখার চেষ্টা করার কোনও মানে হয় না। যদি এটি আরও ভাল না হতে পারে তবে খনন চালিয়ে যাবেন না।
উপরের ছাঁটাইটি আরও ভাল কাজ করে যদি আপনি "খারাপ" ব্যক্তিদের দিকে তাকানোর আগে "ভাল" প্রার্থীদের দিকে নজর দেন (যেমনটি হয়, ঘরগুলি সমস্ত বাম থেকে ডানদিকে, উপরে থেকে নীচে ক্রমে দেখানো হয়)। বেশিরভাগ সংযোগবিহীন উপাদানগুলির নিকটে থাকা কোষগুলি কোষের তুলনায় উচ্চ-অগ্রাধিকার হিসাবে বিবেচনা করা একটি উত্তম তাত্ত্বিক। যাইহোক, আপনি একবার হিউরিস্টিকস যুক্ত করলে, আপনার অনুসন্ধান এ * এর সাথে সাদৃশ্য হতে শুরু করে (এবং আপনারও এক প্রকার অগ্রাধিকারের সারির দরকার আছে)।
কোথাও সদৃশ সেতু এবং সেতু এড়ানো যায় না। অপসারণ করা থাকলে যে কোনও ব্রিজ দ্বীপ নেটওয়ার্ক সংযোগ বিচ্ছিন্ন করে না তা রিলান্ড্যান্ট।

A * এর মতো একটি সাধারণ অনুসন্ধান অ্যালগরিদম আরও দ্রুত অনুসন্ধানের অনুমতি দেয় যদিও আরও ভাল হিউরিস্টিক্স সন্ধান করা কোনও সহজ কাজ নয়। আরও সমস্যা-নির্দিষ্ট পদ্ধতির জন্য, @ গাসার পরামর্শ অনুসারে স্টেইনার গাছগুলিতে বিদ্যমান ফলাফলগুলি ব্যবহার করার উপায়। নোট, তবে, গ্যারি এবং জনসনের এই গবেষণাপত্র অনুসারে অर्थোগোনাল গ্রিডগুলিতে স্টেইনার গাছ তৈরির সমস্যাটি এনপি-কমপ্লিট ।

যদি "যথেষ্ট ভাল" যথেষ্ট হয় তবে একটি জেনেটিক অ্যালগরিদম সম্ভবত গ্রহণযোগ্য সমাধানগুলি দ্রুত খুঁজে পেতে পারে, যতক্ষণ না আপনি পছন্দসই সেতু স্থাপনের ক্ষেত্রে কয়েকটি মূল তাত্পর্য যুক্ত করেন।

Question 4

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

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

Question 5

এই সমস্যাটি গ্রিডে সংঘটিত হয় এবং আপনার যথাযথ সংজ্ঞা দেওয়া প্যারামিটার রয়েছে, আমি ন্যূনতম বিস্তৃত গাছ তৈরির মাধ্যমে সমস্যাটির স্থানটি নিয়মিত নির্মূলকরণের সাথে সমস্যার সাথে যোগাযোগ করব। এটি করার মাধ্যমে, আপনি যদি প্রাইমের অ্যালগরিদমের সাথে এই সমস্যাটির কাছে যান তবে আমার কাছে তা বোধগম্য হয়।

দুর্ভাগ্যক্রমে, আপনি এখন নোড এবং প্রান্তের একটি সেট তৈরি করতে গ্রিডটি বিমোচন করার সমস্যায় পড়েছেন ... এই পোস্টের আসল সমস্যাটি হ'ল আমি কীভাবে আমার এনএক্সএম গ্রিডকে {ভি} এবং {ই} এ রূপান্তর করব?

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

এটি হয়ে গেলে, প্রাইমের আলগোরিদম চালান এবং আপনার সর্বোত্তম সমাধানে পৌঁছানো উচিত।

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

আপনি যদি কোডটি (ছদ্ম বা অন্যথায়) চান তবে আপনার গ্রিডটিকে into V} এবং {E} এর সেটে রূপান্তর করতে চান, দয়া করে আমাকে একটি ব্যক্তিগত বার্তা প্রেরণ করুন এবং আমি একসাথে একটি প্রয়োগ বাস্তবায়িত হয়ে দেখব।