सभी द्वीपों को जोड़ने के लिए न्यूनतम लागत क्या है?

Question 1

वहाँ आकार का एक ग्रिड है एन एक्स एम । कुछ कोशिकाएँ '0' द्वारा निरूपित द्वीप हैं और अन्य जल हैं । प्रत्येक जल प्रकोष्ठ पर एक संख्या होती है जो उस प्रकोष्ठ पर बने पुल की लागत को दर्शाती है। आपको न्यूनतम लागत का पता लगाना होगा जिसके लिए सभी द्वीपों को जोड़ा जा सकता है। एक सेल दूसरे सेल से जुड़ा होता है अगर वह एक किनारे या एक शीर्ष साझा करता है।

इस समस्या को हल करने के लिए क्या एल्गोरिदम का उपयोग किया जा सकता है? यदि N, M का मान बहुत छोटा है, तो एक क्रूर बल दृष्टिकोण के रूप में क्या इस्तेमाल किया जा सकता है, NxM <= 100?

उदाहरण : दी गई छवि में, हरी कोशिकाएँ द्वीपों को दर्शाती हैं, नीली कोशिकाएँ पानी को इंगित करती हैं और हल्की नीली कोशिकाएँ उन कोशिकाओं को इंगित करती हैं जिन पर एक पुल बनाया जाना चाहिए। इस प्रकार निम्नलिखित छवि के लिए, उत्तर 17 होगा ।

शुरू में मैंने सभी द्वीपों को नोड्स के रूप में चिह्नित करने और एक छोटी पुल द्वारा द्वीपों के हर जोड़े को जोड़ने के बारे में सोचा। तब समस्या को कम से कम फैले हुए पेड़ तक कम किया जा सकता था, लेकिन इस दृष्टिकोण में मैंने उस मामले को याद किया जहां किनारों को ओवरलैपिंग किया गया था। उदाहरण के लिए , निम्नलिखित छवि में, किसी भी दो द्वीपों के बीच की सबसे छोटी दूरी 7 (पीले रंग में चिह्नित) है, इसलिए न्यूनतम स्पैनिंग पेड़ों का उपयोग करके उत्तर 14 होगा , लेकिन उत्तर 11 होना चाहिए (हल्के नीले रंग में चिह्नित)।

Question 2

इस समस्या से निपटने के लिए, मैं एक पूर्णांक प्रोग्रामिंग ढांचे का उपयोग करेगा और निर्णय चर के तीन सेटों को परिभाषित करेगा:

x_ij : बाइनरी इंडिकेटर वैरिएबल है कि क्या हम पानी के स्थान पर पुल बनाते हैं (i, j)।
y_ijbcn : पानी के स्थान (i, j) के लिए एक बाइनरी संकेतक n ^ वें स्थान है जो द्वीप b को द्वीप c से जोड़ता है।
l_bc : द्वीपसमूह ख और ग के लिए एक द्विआधारी संकेतक चर सीधे जुड़ा हुआ है (उर्फ आप केवल पुल वर्गों पर ख से ग तक चल सकते हैं)।

पुल निर्माण की लागत c_ij के लिए , न्यूनतम करने के लिए उद्देश्य मूल्य है sum_ij c_ij * x_ij। हमें निम्नलिखित बाधाओं को मॉडल में जोड़ने की आवश्यकता है:

हमें यह सुनिश्चित करने की आवश्यकता है कि y_ijbcn चर वैध हैं। हम हमेशा केवल एक पानी के वर्ग तक पहुंच सकते हैं यदि हम वहां एक पुल का निर्माण करते हैं, तो y_ijbcn <= x_ijहर पानी के स्थान (i, j) के लिए। इसके अलावा, y_ijbc1बराबर होना चाहिए 0 अगर (i, j) बॉर्डर आइलैंड b नहीं है। अंत में, n> 1 के लिए, y_ijbcnकेवल तभी उपयोग किया जा सकता है जब चरण n-1 में पड़ोसी पानी के स्थान का उपयोग किया गया हो। N(i, j)पानी के वर्गों को परिभाषित करना पड़ोसी (i, j) है, यह बराबर है y_ijbcn <= sum_{(l, m) in N(i, j)} y_lmbc(n-1)।
हमें यह सुनिश्चित करने की आवश्यकता है कि l_bc वैरिएबल केवल सेट किए गए हैं यदि b और c लिंक हैं। यदि हम I(c)द्वीप सी की सीमा वाले स्थानों को परिभाषित करते हैं, तो इसे पूरा किया जा सकता है l_bc <= sum_{(i, j) in I(c), n} y_ijbcn।
हमें यह सुनिश्चित करने की आवश्यकता है कि सभी द्वीप सीधे या परोक्ष रूप से जुड़े हुए हैं। इसे निम्नलिखित तरीके से पूरा किया जा सकता है: द्वीपों के प्रत्येक गैर-रिक्त उचित उप-समूह के लिए, यह आवश्यक है कि S के कम से कम एक द्वीप S के पूरक में कम से कम एक द्वीप से जुड़ा हो, जिसे हम S कहेंगे। बाधाओं में, हम आकार के हर गैर-खाली सेट के लिए एक बाधा जोड़कर इसे लागू कर सकते हैं <= K / 2 (जहां K द्वीपों की संख्या है) 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

आपके द्वारा प्राप्त किए गए समाधानों की गुणवत्ता में सुधार करने के लिए, आप एक वाणिज्यिक एमआईपी सॉल्वर का उपयोग कर सकते हैं (यह मुफ़्त है यदि आप एक शैक्षणिक संस्थान में हैं और संभवतः अन्यथा मुक्त नहीं हैं)। मिसाल के तौर पर, यहाँ पर गुरूबी ६.०.४ का प्रदर्शन, फिर से २ मिनट की समय सीमा के साथ (हालाँकि समाधान लॉग से हम पढ़ते हैं कि सॉल्वर को solution सेकंड के भीतर वर्तमान सबसे अच्छा समाधान मिला):

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

यह वास्तव में वस्तुनिष्ठ मूल्य 16 का हल ढूंढता है, ओपी से बेहतर एक हाथ से खोजने में सक्षम था!

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

C ++ में, इसे इस प्रकार लिखा जा सकता है

// 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);
}

पहला कॉल करने के बाद (मैं मान रहा हूं कि आप अपने 2d नक्शे को 1d सरणियों में चारों ओर नकल करने में आसानी के लिए बदल रहे हैं), bestCostइसमें सर्वोत्तम उत्तर की लागत bestशामिल होगी , और इसमें पुलों का पैटर्न शामिल होगा जो इसकी पैदावार करता है। हालांकि यह बेहद धीमी है।

अनुकूलन:

एक "पुल सीमा" का उपयोग करके, और पुलों की अधिकतम संख्या बढ़ाने के लिए एल्गोरिथ्म चलाकर, आप पूरे पेड़ की खोज किए बिना न्यूनतम उत्तर पा सकते हैं। 1-पुल का उत्तर खोजना, यदि यह मौजूद था, तो O (2 ^ nm) के बजाय O (nm) होगा - एक कठोर सुधार।
आप खोज करने से बच सकते हैं (पुनरावृत्ति को रोककर; इसे एक बार पार bestCostकरने के बाद "प्रूनिंग" भी कहा जाता है , क्योंकि यह बाद में देखते रहने का कोई मतलब नहीं है। यदि यह बेहतर नहीं हो सकता है, तो खुदाई न रखें।
उपरोक्त प्रूनिंग बेहतर काम करती है यदि आप "अच्छे" उम्मीदवारों को "बुरे" वाले (जैसा कि होता है) देखने से पहले देखते हैं, कोशिकाओं को बाएं से दाएं, ऊपर से नीचे के क्रम में देखा जाता है)। एक अच्छा अनुमानी उन कोशिकाओं पर विचार करना होगा जो कई असंबद्ध घटकों के पास हैं जो कोशिकाओं की तुलना में उच्च-प्राथमिकता के रूप में हैं। हालांकि, एक बार जब आप उत्तराधिकार जोड़ लेते हैं, तो आपकी खोज A * जैसी लगने लगती है (और आपको किसी प्रकार की प्राथमिकता कतार की भी आवश्यकता होती है)।
डुप्लीकेट पुलों और पुलों को कहीं नहीं रखा जाना है। कोई भी पुल जो हटाए जाने पर द्वीप नेटवर्क को डिस्कनेक्ट नहीं करता है।

एक सामान्य खोज एल्गोरिथ्म जैसे ए * बहुत तेजी से खोज की अनुमति देता है, हालांकि बेहतर उत्तराधिकार खोजना एक आसान काम नहीं है। अधिक समस्या-विशिष्ट दृष्टिकोण के लिए, @ गस्सा द्वारा सुझाए गए स्टेनर पेड़ों पर मौजूदा परिणामों का उपयोग करना, जाने का रास्ता है। ध्यान दें, हालांकि, गैरी और जॉनसन द्वारा इस पत्र के अनुसार, ऑर्थोगोनल ग्रिड पर स्टेनर पेड़ों के निर्माण की समस्या एनपी-पूर्ण है ।

यदि "पर्याप्त पर्याप्त" पर्याप्त है, तो एक आनुवंशिक एल्गोरिथ्म शायद स्वीकार्य समाधान जल्दी से पा सकता है, जब तक कि आप पसंदीदा पुल प्लेसमेंट के रूप में कुछ प्रमुख उत्तराधिकार जोड़ते हैं।

Question 4

यह समस्या नट -भार वाले स्टीनर वृक्ष नामक स्टेनर वृक्ष का एक प्रकार है , जो एक निश्चित वर्ग ग्राफ का है। कॉम्पैक्ट रूप से, नोड-वेटेड स्टाइनर ट्री है, एक नोड-वेटेड अप्रत्यक्ष ग्राफ दिया गया है जहां कुछ नोड्स टर्मिनल हैं, सभी टर्मिनलों सहित नोड्स का सबसे सस्ता सेट खोजें जो एक कनेक्टेड सबग्राफ को प्रेरित करता है। अफसोस की बात यह है कि मुझे कुछ सरसरी खोजों में कोई सॉल्वर नहीं मिल रहा है।

पूर्णांक कार्यक्रम के रूप में तैयार करने के लिए, प्रत्येक गैर-टर्मिनल नोड के लिए 0-1 चर बनाएं, फिर गैर-टर्मिनल नोड्स के सभी सबसेट के लिए जिनके शुरुआती ग्राफ से हटाने से दो टर्मिनलों को डिस्कनेक्ट किया जाता है, इसके लिए सबसे उप में चर का योग होना चाहिए। कम से कम 1. यह बहुत अधिक बाधाओं को प्रेरित करता है, इसलिए आपको अधिकतम उल्लंघन वाले बाधा का पता लगाने के लिए नोड कनेक्टिविटी (अधिकतम प्रवाह, मूल रूप से) के लिए एक कुशल एल्गोरिथ्म का उपयोग करके, उन्हें आलसी रूप से लागू करना होगा। विवरणों की कमी के लिए क्षमा करें, लेकिन यह लागू करने के लिए एक दर्द होने जा रहा है, भले ही आप पहले से ही पूर्णांक प्रोग्रामिंग से परिचित हों।

Question 5

यह देखते हुए कि यह समस्या एक ग्रिड में होती है, और आपके पास अच्छी तरह से परिभाषित पैरामीटर हैं, मैं एक न्यूनतम फैले पेड़ बनाने के माध्यम से समस्या स्थान के व्यवस्थित उन्मूलन के साथ समस्या का सामना करूंगा। ऐसा करने पर, यह मेरे लिए समझ में आता है यदि आप प्राइम के एल्गोरिथम के साथ इस समस्या का सामना करते हैं।

दुर्भाग्य से, आप अब नोड और किनारों का एक सेट बनाने के लिए ग्रिड को दूर करने की समस्या में भाग लेते हैं ... इस पोस्ट की वास्तविक समस्या यह है कि मैं अपने nxm ग्रिड को {V} और {E} में कैसे परिवर्तित करूं?

यह रूपांतरण प्रक्रिया एक नज़र में, संभवत: संयोजन की सरासर संख्या के कारण एनपी-हार्ड होने की संभावना है (मान लें कि सभी जलमार्ग लागत समान हैं)। ऐसे उदाहरणों को संभालने के लिए जहां रास्ते ओवरलैप होते हैं, आपको एक आभासी द्वीप बनाने पर विचार करना चाहिए ।

जब यह हो जाता है, तो प्राइम के एल्गोरिथ्म को चलाएं और आपको इष्टतम समाधान पर पहुंचना चाहिए।

मुझे विश्वास नहीं है कि डायनेमिक प्रोग्रामिंग को प्रभावी ढंग से यहां चलाया जा सकता है क्योंकि इष्टतमता का कोई अवलोकन सिद्धांत नहीं है। यदि हम दो द्वीपों के बीच न्यूनतम लागत पाते हैं, तो इसका मतलब यह नहीं है कि हम उन दो और तीसरे द्वीप के बीच न्यूनतम लागत पा सकते हैं, या द्वीपों का एक अन्य सबसेट जो प्राइम के माध्यम से एमएसटी को खोजने के लिए मेरी परिभाषा के अनुसार होगा) जुड़े हुए।

यदि आप अपने ग्रिड को {V} और {E} के सेट में बदलने के लिए कोड (छद्म या अन्यथा) चाहते हैं, तो कृपया मुझे एक निजी संदेश भेजें और मैं एक कार्यान्वयन पर एक साथ प्रयास करूंगा।