कॉनकॉर्ड की दुर्दशा

Question

पृष्ठभूमि

यात्रा विक्रेता की समस्या (TSP) कम से कम सर्किट के लिए पूछता है कि दौरा शहरों की दी गई संग्रह। इस सवाल के प्रयोजनों के लिए, शहर विमान में बिंदु होंगे और उनके बीच की दूरी सामान्य यूक्लिडियन दूरी (निकटतम पूर्णांक तक गोल) होगी। सर्किट "राउंड-ट्रिप" होना चाहिए, जिसका अर्थ है कि यह शुरुआती शहर में वापस आना चाहिए।

कॉनकॉर्ड TSP solver इयूक्लिडियन यात्रा विक्रेता की समस्या के उदाहरण हल कर सकते हैं, वास्तव में और बहुत तेजी से एक से उम्मीद होती है। उदाहरण के लिए, कॉनकॉर्ड 85,900-बिंदु उदाहरण को वास्तव में हल करने में सक्षम था , जिसके कुछ हिस्से इस तरह दिखते हैं:

हालांकि, कॉनकॉर्ड के लिए कुछ टीएसपी के उदाहरण बहुत लंबे समय तक लेते हैं। उदाहरण के लिए, कोई भी मोना लिसा के आधार पर इस 100,000-बिंदु उदाहरण को हल करने में सक्षम नहीं है । (यदि आप इसे हल कर सकते हैं तो $ 1,000 का पुरस्कार दिया जा सकता है!)

कॉनकॉर्ड स्रोत कोड या एक निष्पादन योग्य के रूप में डाउनलोड के लिए उपलब्ध है । डिफ़ॉल्ट रूप से, यह बिल्ट-इन लीनियर प्रोग्राम (LP) सॉल्वर QSopt का उपयोग करता है , लेकिन यह CPLEX जैसे बेहतर LP सॉल्वर का भी उपयोग कर सकता है।

चुनौती

सबसे छोटा टीएसपी उदाहरण क्या है जिसे आप हल कर सकते हैं जो कॉनकॉर्ड को हल करने में पांच मिनट से अधिक समय लेता है ?

आप उदाहरण को आउटपुट करने के लिए एक प्रोग्राम लिख सकते हैं, या किसी अन्य विधि का उपयोग कर सकते हैं जो आप चाहते हैं।

स्कोरिंग

उदाहरण में कम अंक बेहतर हैं। उदाहरण के फ़ाइल आकार से संबंध टूट जाएंगे (नीचे देखें)।

मानकीकरण

विभिन्न कंप्यूटर तेज़ या धीमे चलते हैं, इसलिए हम रनटाइम के माप के मानक के रूप में कॉनकॉर्ड के लिए NEOS सर्वर का उपयोग करेंगे। आप निम्नलिखित सरल 2-घ समन्वय फॉर्म में बिंदुओं की एक सूची प्रस्तुत कर सकते हैं:

#cities
x_0 y_0
x_1 y_1
.
.
.
x_n-1 y_n-1

एनईओएस पर जिन सेटिंग्स का उपयोग किया जाना चाहिए, वे हैं "कॉनकॉर्ड डेटा (एक्स-लिस्ट फ़ाइल, एल 2 नॉर्म्स)", "एलगोरिदम: कॉनकॉर्ड (क्यूसॉप्ट)", और "रैंडम सीड: फिक्स्ड"।

बेसलाइन

TSPLIBrl1889.tsp से 1,889-बिंदु उदाहरण "कुल रनिंग समय: 871.18 (सेकंड)" लेता है, जो पांच मिनट से अधिक है। यह इस तरह दिख रहा है:

Comments

हार्ड कॉनकोड मामलों को उत्पन्न करने पर प्रासंगिक एसई पद ।

— 8

Answer 1

एनईओएस पर 88 शहर, 341 सेकंड रनटाइम

हाल के एक पेपर में हमने यूक्लिडियन टीएसपी उदाहरणों को हल करने के लिए कठिन परिवार का निर्माण किया। आप इस परिवार से उदाहरणों को डाउनलोड कर सकते हैं और साथ ही उन्हें यहाँ उत्पन्न करने के लिए कोड भी दे सकते हैं:

http://www.or.uni-bonn.de/%7Ehougardy/HardTSPInstances.html

इस परिवार के 88 शहर का उदाहरण NEOS सर्वर पर कॉनकॉर्ड को 5 मिनट से अधिक समय लेता है। इस परिवार का 178-शहर का उदाहरण हल करने के लिए पहले ही एक दिन से अधिक समय लेता है।

Comments

ये अद्भुत है!!

— ए। रेक्स

बहुत अच्छा पेपर! आश्चर्यजनक परिणाम। आप इस पर पूरी तरह से जीत के लायक हैं!

— 20

Answer 2

NEOS पर 77 शहर, 7.24 मिनट (434.4 सेकंड) का औसत रन समय

मुझे पार्टी में थोड़ी देर हो गई है, लेकिन मैं 77-नोड का उदाहरण देना चाहता हूं, weruSnowflake77।

मैंने इस उदाहरण को यह समझने की कोशिश करते हुए बनाया कि कौन सी स्थानीय और वैश्विक विशेषताएं समय की मात्रा पर एक ऊपरी दबाव लगाती हैं, जो अपने सबसे कम पाए गए दौरे की लंबाई के साथ अपनी सबसे अच्छी निचली सीमा से मेल खाती है।

इस उदाहरण का निर्माण करने के लिए, मैंने एक बेस ग्राफ (13 x 13 वर्ग) के साथ शुरू किया, और फिर व्यवस्थित रूप से नए अंक या अनुवादित पुराने बिंदुओं को पेश किया, जो समायोजन को बनाए रखने के लिए बनाए गए थे जो काटने से पहले औसतन अपनी शाखाओं में गहराई से जाते हैं।

तकनीक उसी तरह से है जैसे कि एक आनुवंशिक एल्गोरिथ्म मौजूदा पर्यटन को बदल देता है और अगली पीढ़ी के उत्परिवर्तन के लिए छोटी यात्राओं को बनाए रखता है, सिवाय इसके कि ग्राफ को उत्परिवर्तित किया जा रहा है और कठिन-से-हल ग्राफ़ को बनाए रखा जाता है। यह उस तरह से भी है जैसे हम कम निचली सीमा के निर्माण में मदद करने के लिए विश्राम का उपयोग करते हुए ग्राफ़ को म्यूट करते हैं, इसके विपरीत मैं जा रहा हूं, निचले सीमा को खोजने के लिए एक मौजूदा ग्राफ़ को हार्ड के साथ ग्राफ़ बनाने के लिए म्यूट कर रहा हूं।

इस प्रक्रिया में मुझे कुछ छोटे ग्राफ़ मिले हैं जिन्हें हल करने के लिए कॉनकॉर्ड मिनट लगते हैं, लेकिन यह पहला छोटा ग्राफ़ है जो मैंने पाया है कि कॉनकॉर्ड को न्यूनतम 5 मिनट लगते हैं।

तय बीज और QSopt का उपयोग करके NEOS पर 10 परीक्षण रन के साथ, औसत रनटाइम 7.24 मिनट (434.531 सेकंड) था। न्यूनतम रनटाइम 5.6 मिनट (336.64 सेकंड) था। अधिकतम रनटाइम 8.6 मिनट (515.80 सेकंड) था। कोई परीक्षण नहीं किया गया। नीचे पूर्ण बेंचमार्क तालिका:

बेंचमार्क परिणाम 10 रन से अधिक:

----------------------------------
| Run | Job ID# | Total running  |
|     |         | time (seconds) |
|-----|---------|----------------|
| 1   | 7739963 | 513.44         |
| 2   | 7740009 | 336.64         |
| 3   | 7740023 | 514.25         |
| 4   | 7740029 | 447.97         |
| 5   | 7740038 | 357.10         |
| 6   | 7740072 | 447.47         |
| 7   | 7740073 | 336.19         |
| 8   | 7740075 | 515.80         |
| 9   | 7740088 | 361.26         |
| 10  | 7740091 | 515.19         |
----------------------------------

weruSnowflake77 (xy सूची, L2 मानदंड):

77
-700 -700
700 -700
200 0
0 200
-200 0
0 -200
0 0
-600 600
-500 600
-400 600
-300 600
-200 600
-100 600
0 600
100 600
200 600
300 600
400 600
500 600
600 600
-600 -600
-500 -600
-400 -600
-300 -600
-200 -600
-100 -600
0 -600
100 -600
200 -600
300 -600
400 -600
500 -600
600 -600
600 -500
600 -400
600 -300
600 -200
600 -100
600 0
600 100
600 200
600 300
600 400
600 500
-600 -500
-600 -400
-600 -300
-600 -200
-600 -100
-600 0
-600 100
-600 200
-600 300
-600 400
-600 500
-500 -500
-400 -400
-300 -300
-200 -200
-100 -100
100 100
200 200
300 300
400 400
500 500
100 -100
200 -200
300 -300
400 -400
500 -500
-100 100
-200 200
-300 300
-400 400
-500 500
700 700
-700 700

कोष

• Github URL: https://github.com/LDubya/weruSnowflake77

रेपो से समस्या सेट फ़ाइलें:

• weruSnowflake77.txt (xy सूची फ़ाइल, L2 मानदंड)
• weruSnowflake77.tsp (TSPLIB प्रारूप, EUC_2D)

Comments

ठंडा! यदि आप इसे अपने पोस्ट में संपादित करना चाहते हैं, तो आपके उदाहरण की एक तस्वीर यहां दी गई है: i.stack.imgur.com/DnJ7T.png

— A. Rex

@ A.Rex धन्यवाद! हाँ, यह एक इष्टतम मार्गों में से एक है। यह (काल्पनिक रूप से) एक ही इष्टतम लंबाई के विभिन्न मार्गों के बहुत सारे होना चाहिए। क्या हमारे लिए एक अच्छा तरीका है कि हम कितने अलग-अलग इष्टतम मार्गों का उपयोग कर सकते हैं? यदि कॉनकॉर्ड शाखा और कटौती करता है, तो मुझे यकीन है कि यह सभी शाखाओं को याद कर सकता है जो समान लंबाई के हैं ...

— लॉरेंस वेरु

Answer 3

पायथन 3, 911 शहर, NEOS पर 1418 सेकंड का रन टाइम

निम्नलिखित पायथन 3.x स्क्रिप्ट 911 शहरों के निर्देशांक उत्पन्न करता है। 47739 के सबसे छोटे रास्ते की गणना करने के लिए NEOS 1418 सेकंड का समय लगा।

यहाँ तुम्हारा सबसे छोटा रास्ता है (धन्यवाद ए रेक्स के लिए):

कोड / एल्गोरिथ्म Feigenbaum द्विभाजन पर आधारित है , जिसका उपयोग मैंने मूल्यों की एक श्रृंखला उत्पन्न करने के लिए किया था, जिसका उपयोग मैंने शहरों के निर्देशांक उत्पन्न करने के लिए एक आधार के रूप में किया था। जब तक मैंने 1000 से कम संख्या में शहरों को नहीं पाया, तब तक मैंने मापदंडों के साथ प्रयोग किया, जिसमें एनईओएस को आश्चर्यजनक समय मिला (अच्छी तरह से आवश्यक 5 मिनट से ऊपर)।

x = 0.579
coords = []
for _ in range(1301):
    if int(3001*x) not in coords:
        coords.append(int(3001*x))
    x = 3.8*x*(1-x)
coords = list(zip(coords, coords[::-1]))
print(len(coords))
for coord in coords:
    print(f"{coord[0]} {coord[1]}")

PS: मेरे पास कम संख्या में शहरों की खोज में चलने वाली स्क्रिप्ट है जो NEOS पर भी> 5 मिनट लेती है। अगर मुझे कोई मिल जाए तो मैं उन्हें इस उत्तर में पोस्ट करूँगा।

पुनश्च: अरे! इस स्क्रिप्ट को एल पैरामीटर 1811 के साथ चलाने के बजाय 1301 परिणाम 1156 शहरों में केवल 4 घंटे से अधिक के एनओएसओएस पर चल रहे हैं , जो समान मापदंडों के साथ अन्य मामलों की तुलना में बहुत अधिक है ...

Comments

यदि आप इसे अपनी पोस्ट में संपादित करना चाहते हैं, तो आपके 911 शहर के दौरे की एक तस्वीर यहाँ दी गई है: i.imgur.com/G1ZPX0k.png

— A. Rex

@ A.Rex धन्यवाद इसे जोड़ा।

— agtoever