पूर्णांक रैखिक प्रोग्रामिंग

Question

परिचय

पूर्णांक रैखिक प्रोग्रामिंग के लिए एक सॉल्वर लिखें ।

चुनौती

आपका कार्य पूर्णांक रैखिक प्रोग्रामिंग (ILP) के लिए एक सॉल्वर लिख रहा है। ILP में, अज्ञात के एक सेट की रैखिक असमानताएं (जिनमें से सभी पूर्णांक हैं) दिए गए हैं, और लक्ष्य एक रैखिक फ़ंक्शन का न्यूनतम या अधिकतम पता लगाना है।

उदाहरण के लिए, असमानताओं के लिए (मिसाल इंटेर्गर लीनियर प्रोग्रामिंग से लिया गया उदाहरण )

 4x+2y-15≤0
  x+2y- 8≤0
  x+ y- 5≤0
- x      ≤0
   - y   ≤0

और वस्तुनिष्ठ फ़ंक्शन 3x+2y, वस्तुनिष्ठ फ़ंक्शन का अधिकतम 12( x=2,y=3) होना चाहिए , जबकि न्यूनतम होना चाहिए 0( x=y=0)।

इनपुट को 2d सरणी (या मानक विनिर्देशों का पालन करने वाला कोई भी समकक्ष) के रूप में दिया जाता है, प्रत्येक पंक्ति अंतिम पंक्ति के अपवाद के साथ एक असमानता से मेल खाती है। सरणी में संख्याएँ गुणांक हैं, और ≤0भाग हमेशा छोड़ा जाता है। यदि nप्रत्येक पंक्ति में तत्व हैं , तो इसका मतलब है कि n-1अज्ञात हैं।

सरणी की अंतिम पंक्ति रैखिक फ़ंक्शन के अनुरूप है। गुणांक सूचीबद्ध हैं।

उदाहरण के लिए, ऊपर की समस्या के लिए इनपुट सरणी है

[[4,2,-15],[1,2,-8],[1,1,-5],[-1,0,0],[0,-1,0],[3,2,0]].

आउटपुट न्यूनतम और अधिकतम होना चाहिए, जो किसी भी उचित रूप में दिया गया हो।

निम्नलिखित समस्या के लिए (दो प्रतिबंध ऊपर की समस्या से दूर ले जाते हैं):

[[4,2,-15],[1,2,-8],[1,1,-5],[3,2,0]].

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

[[4,2,-15],[-1,-2,7],[-1,0,3],[0,1,0],[3,2,0]].

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

इनपुट में केवल असमानताओं के लिए और उद्देश्य फ़ंक्शन के लिए पूर्णांक गुणांक होते हैं। सभी अज्ञात भी पूर्णांक हैं। असमानताओं के गुणांक मैट्रिक्स को पूर्ण रैंक की गारंटी है।

परीक्षण के मामलों

इसका श्रेय @KirillL को है। मूल परीक्षण सूट में बग ढूंढने और ILP समस्याओं के बारे में मेरी समझ को गहरा करने के लिए।

Input
Output

[[4,2,-15],[1,2,-8],[1,1,-5],[-1,0,0],[0,-1,0],[3,2,1]]
[1,13]

[[4,2,-15],[1,2,-8],[1,1,-5],[3,2,0]]
[-inf, 12]

[[4,2,-15],[-1,-2,7],[-1,0,3],[0,1,0],[3,2,0]]
[NaN, NaN]

[[-1,-1,-1,-1,-1,8],[1,1,1,1,0,0],[5,5,5,5,6,7]]
[55, inf]

[[-1,-1,-1,-1,-1,8],[1,1,1,1,0,0],[0,0,0,0,0,4]]
[4, 4]

[[4,2,-15],[-1,-2,7],[-1,0,3],[0,1,0],[0,0,4]]
[NaN, NaN]

चश्मा

• अपवाद हैंडलिंग के बारे में चिंता करने की कोई जरूरत नहीं है।

• यह कोड-गोल्फ है , सबसे कम संख्या में बाइट्स जीतती हैं।

• अज्ञात की अधिकतम संख्या 9:। विषमताओं की अधिकतम संख्या 12:।

• आप इनपुट ले सकते हैं और किसी भी मानक फॉर्म के माध्यम से आउटपुट प्रदान कर सकते हैं , और आप प्रारूप चुनने के लिए स्वतंत्र हैं।

• हमेशा की तरह, डिफ़ॉल्ट कमियां यहां लागू होती हैं।

Comments

Generalises codegolf.stackexchange.com/q/155460/194

— पीटर टेलर

आपने स्पष्ट रूप से कार्य विवरण में इसका उल्लेख नहीं किया है, लेकिन मुझे संदेह है कि आप एल्गोरिथ्म के मूल कार्यान्वयन की मांग कर रहे हैं, न कि कुछ उबाऊ कोड जो मौजूदा पुस्तकालयों का उपयोग करते हैं? फिर भी, मैंने R में आपके परीक्षण मामलों के साथ खेला और परिणामों को बिल्कुल पुन: पेश नहीं कर सका। उदाहरण के लिए, [55, inf] मामला केवल तभी काम करता है जब चर गैर-नकारात्मक हो। लेकिन फिर [-इनफ, 12] मामला सामान्य परिणाम भी पैदा करता है [0, 12]। दूसरी ओर, जब निचला बाउंड -inf होता है, तो [55, inf] केस मिनट और अधिकतम दोनों परिदृश्यों में हल करने में विफल रहता है।

— किरिल एल।

हां मैं मूल कार्यान्वयन की तलाश में हूं।

— वीजुन झोउ

@KirillL। क्या आप एक वेक्टर प्रदान कर सकते हैं जहां परीक्षण के मामले में कार्य [55, inf] 55 से छोटा मान देता है? मैंने इसे एक ऑनलाइन सॉल्वर के खिलाफ जांचा और मामला ठीक लग रहा है। इस परीक्षण के मामले को बनाते समय मेरे पास निम्नलिखित तर्क हैं: पहले प्रतिबंध के लिए सभी नि: शुल्क चर के योग की आवश्यकता होती है जेक 8, लेकिन दूसरे को अंतिम के अलावा सभी के योग की आवश्यकता होती है। पहले 4 फ्री वर्जन में से किसी एक को कम करके लक्ष्य को अंतिम वर्जन को उसी राशि से बढ़ाना होगा इसलिए लक्ष्य के लिए एक बड़ा मूल्य होगा।

— वीजुन झोउ

यहाँ मेरा स्निपेट है , हालाँकि लाइब्रेरी गुम होने के कारण यह TIO पर काम नहीं करेगा। यह 55 देता है, लेकिन जब मैं सेट.बाउंड लाइन को अनफिल्ट करता है तो "मॉडल अनबाउंड" हो जाता है। संभवतः, त्रुटि मेरी तरफ है, हालांकि। क्या आप ऑनलाइन सॉल्वर का लिंक भी दे सकते थे?

— किरिल एल।

Answer 1

पायथन 3 , 534 बाइट्स

import itertools as t
import operator as o
I=float("inf")
e=lambda p,A:sum([i[0]*i[1]for i in zip(p,A[:-1])])+A[-1]
def w(x,j):
	d=len(x[0])-1;C=[0]*d;v,w=I,I
	while 1:
		L={(*n,):(sum([0 if e(n,A)<=0 else e(n,A)for A in x[:-1]]),j*e(n,x[-1]))for n in [[sum(a) for a in zip(C,c)]for c in t.product(*[[-1,0,1]]*d)]};C,P=min(L.items(),key=o.itemgetter(1))[0],C;v,w,p,q=L[C][0],L[C][1],v,w
		if(all([e(C,A)<=e(P,A)for A in x[:-1]]))*(j*(e(C,x[-1])-e(P,x[-1]))<0)+(p==v>0):return I
		if(p==v)*(q<=w):return j*q
f=lambda x:(w(x,1),w(x,-1))

इसे ऑनलाइन आज़माएं!

अवलोकन

यह एक पुनरावृत्त एल्गोरिथ्म है, जो ओरिगो से शुरू होता है। यह पड़ोसी की स्थिति को इकट्ठा करता है और एक संभावित फ़ंक्शन प्रदान करता है: x:(a,b)जहां xस्थिति है, aप्रत्येक रैखिक असमानता के आधे-स्थान से स्थिति की दूरी का योग है, उस स्थिति bमें उद्देश्य का मूल्य है।

x:(a,b) < y:(c,d)iff a<cयाa=c and b<d

चलना बंद हो जाता है, जब:

• क्षमता का पहला समन्वय कम और सकारात्मक नहीं हुआ है: प्रणाली की क्षमता कम है
• हर आधे स्थान से दूरी उद्देश्य की तरह कम हो गई है: सिस्टम अनबाउंड है।
• पिछले और क्षमता में से कोई भी कम नहीं हुआ है: यह इष्टतम मूल्य है।

Answer 2

मतलाब, 226 बाइट्स

अस्वीकरण : केवल मनोरंजन के लिए "मूल" कार्यान्वयन नहीं।

intlinprogसमारोह का लाभ उठाते हुए सरल उपाय :

function r=f(a);b=-1*a(1:end-1,end);p=a(end,1:end-1);c=a(1:end-1,1:end-1);[~,f,h]=intlinprog(p,1:size(a,2)-1,c,b);[~,g,i]=intlinprog(-p,1:size(a,2)-1,c,b);s=[inf,nan,f];t=[inf,nan,g];r=a(end,end)+[s(4-abs(h)) -t(4-abs(i))];end

यदि यह समस्या दूर हो या कम हो, तो यह इष्टतम मान, या inf (-inf) लौटाता है।

a = [4 2 -15; 1 2 -8; 1 1 -5; -1 0 0; 0 -1 0; 3 2 1]
b = [4 2 -15; 1 2 -8; 1 1 -5; 3 2 0]
c = [4 2 -15; -1 -2 7; -1 0 3; 0 1 0; 3 2 0]
d = [-1 -1 -1 -1 -1 8;  1 1 1 1 0 0; 0 0 0 0 0 4]
e = [4 2 -15; -1 -2 7; -1 0 3; 0 1 0; 0 0 4]

>> f(a)
ans =

     1    13

>> f(b)
ans =

   Inf    12

>> f(c)
ans =

   NaN   NaN

>> f(d)
ans =

     4     4

>> f(e)
ans =

   NaN   NaN