न्यूनतम-लागत प्रवाह समस्या

एक प्रवाह नेटवर्कG = (V, E) एक स्रोत शीर्ष s ϵ Vऔर एक सिंक शीर्ष के साथ एक निर्देशित ग्राफ है t ϵ V, और जहां (u, v) ϵ Eग्राफ पर हर किनारे (नोड्स को जोड़ने ) u ϵ Vऔर v ϵ Vइसके साथ जुड़े 2 मात्राएं हैं:

c(u, v) >= 0धार की क्षमता
a(u, v) >= 0एक इकाई को किनारे से भेजने की लागत

हम एक फ़ंक्शन 0 <= f(u, v) <= c(u, v)को किसी दिए गए किनारे से गुजरने वाली इकाइयों की संख्या को परिभाषित करते हैं (u, v)। इस प्रकार, किसी दिए गए किनारे की लागत (u, v)है a(u, v) * f(u, v)। निम्न- प्रवाह द्वारा दी गई न्यूनतम राशि के लिए न्यूनतम लागत प्रवाह समस्या को सभी किनारों पर कुल लागत को कम करने के रूप में परिभाषित dकिया गया है:

निम्नलिखित बाधाएँ समस्या पर लागू होती हैं:

क्षमता की आवश्यकताएं : किसी दिए गए किनारे से प्रवाह उस धार की क्षमता से अधिक नहीं हो सकता ( f(u, v) <= c(u, v))।
तिरछा समरूपता : प्रवाह एक दिए गए किनारे को एंटीसिमेट्रिक होना चाहिए जब दिशा उलट हो ( f(u, v) = -f(v, u))।
प्रवाह संरक्षण : किसी भी गैर सिंक गैर स्रोत नोड में शुद्ध प्रवाह 0 होना चाहिए (प्रत्येक के लिए u ∉ {s, t}, सब कुछ खत्म हो संक्षेप w, sum f(u, w) = 0)।
आवश्यक प्रवाह : स्रोत से बाहर शुद्ध प्रवाह और सिंक में शुद्ध प्रवाह दोनों को नेटवर्क के माध्यम से आवश्यक प्रवाह के बराबर होना चाहिए (सभी पर संक्षेप में u, sum f(s, u) = sum f(u, t) = d)।

एक प्रवाह नेटवर्क Gऔर एक आवश्यक प्रवाह को देखते हुए d, dनेटवर्क के माध्यम से इकाइयों को भेजने के लिए न्यूनतम लागत का उत्पादन करता है। आप मान सकते हैं कि एक समाधान मौजूद है। dऔर सभी क्षमता और लागत गैर-नकारात्मक पूर्णांक होंगे। के साथ Nलेबल किए गए वर्टिकल वाले नेटवर्क के लिए [0, N-1], स्रोत शीर्ष होगा 0और सिंक शीर्ष होगा N-1।

ये है कोड गोल्फ, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है। याद रखें कि यह भाषाओं के साथ-साथ भाषाओं के बीच एक प्रतियोगिता है, इसलिए एक क्रिया भाषा में समाधान पोस्ट करने से डरो मत।

बिल्ट-इन की अनुमति है, लेकिन आपको बिना किसी जवाब के अतिरिक्त समाधान के रूप में या स्वतंत्र उत्तर के रूप में, बिना किसी समाधान के शामिल करने के लिए प्रोत्साहित किया जाता है।

इनपुट किसी भी उचित तरीके से हो सकता है जिसमें प्रत्येक किनारे की क्षमता और लागत और मांग शामिल है।

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

परीक्षण के मामले निम्नलिखित प्रारूप में दिए गए हैं:

c=<2D matrix of capacities> a=<2D matrix of costs> d=<demand> -> <solution>

c=[[0, 3, 2, 3, 2], [3, 0, 5, 3, 3], [2, 5, 0, 4, 5], [3, 3, 4, 0, 4], [2, 3, 5, 4, 0]] a=[[0, 1, 1, 2, 1], [1, 0, 1, 2, 3], [1, 1, 0, 2, 2], [2, 2, 2, 0, 3], [1, 3, 2, 3, 0]] d=7 -> 20
c=[[0, 1, 1, 5, 4], [1, 0, 2, 4, 2], [1, 2, 0, 1, 1], [5, 4, 1, 0, 3], [4, 2, 1, 3, 0]] a=[[0, 1, 1, 2, 2], [1, 0, 2, 4, 1], [1, 2, 0, 1, 1], [2, 4, 1, 0, 3], [2, 1, 1, 3, 0]] d=7 -> 17
c=[[0, 1, 4, 5, 4, 2, 3], [1, 0, 5, 4, 3, 3, 5], [4, 5, 0, 1, 5, 5, 5], [5, 4, 1, 0, 3, 2, 5], [4, 3, 5, 3, 0, 4, 4], [2, 3, 5, 2, 4, 0, 2], [3, 5, 5, 5, 4, 2, 0]] a=[[0, 1, 4, 2, 4, 1, 1], [1, 0, 3, 2, 2, 1, 1], [4, 3, 0, 1, 4, 5, 2], [2, 2, 1, 0, 2, 2, 3], [4, 2, 4, 2, 0, 4, 1], [1, 1, 5, 2, 4, 0, 2], [1, 1, 2, 3, 1, 2, 0]] d=10 -> 31
c=[[0, 16, 14, 10, 14, 11, 10, 4, 3, 16], [16, 0, 18, 19, 1, 6, 10, 19, 5, 4], [14, 18, 0, 2, 15, 9, 3, 14, 20, 13], [10, 19, 2, 0, 2, 10, 12, 17, 19, 22], [14, 1, 15, 2, 0, 11, 23, 25, 10, 19], [11, 6, 9, 10, 11, 0, 14, 16, 25, 4], [10, 10, 3, 12, 23, 14, 0, 11, 7, 8], [4, 19, 14, 17, 25, 16, 11, 0, 14, 5], [3, 5, 20, 19, 10, 25, 7, 14, 0, 22], [16, 4, 13, 22, 19, 4, 8, 5, 22, 0]] a=[[0, 12, 4, 2, 9, 1, 1, 3, 1, 6], [12, 0, 12, 16, 1, 2, 9, 13, 2, 3], [4, 12, 0, 2, 2, 2, 2, 10, 1, 1], [2, 16, 2, 0, 2, 1, 8, 4, 4, 2], [9, 1, 2, 2, 0, 5, 6, 23, 5, 8], [1, 2, 2, 1, 5, 0, 13, 12, 12, 1], [1, 9, 2, 8, 6, 13, 0, 9, 4, 4], [3, 13, 10, 4, 23, 12, 9, 0, 13, 1], [1, 2, 1, 4, 5, 12, 4, 13, 0, 13], [6, 3, 1, 2, 8, 1, 4, 1, 13, 0]] d=50 -> 213

इन परीक्षण मामलों की गणना नेटवर्कएक्स पायथन लाइब्रेरी के साथ की गई थी ।

code-golf graph-theory optimization

— मै जाऊं
स्रोत

सैंडबॉक्स

— Mego

एक लंबे समय के लिए गोल्फ तो मुझे एहसास हुआ कि मैं गलत एल्गोरिथ्म का

— अभ्यास

जवाबों:

[R + lpSolve ], 201 186 149 144 बाइट्स

function(c,a,d,`^`=rep,N=ncol(c),G=diag(N),P=t(1^N),M=P%x%G+G%x%-P)lpSolve::lp(,a,rbind(M,diag(N*N)),c('=','<')^c(N,N*N),c(d,0^(N-2),-d,c))$objv

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

कोड निम्नलिखित रैखिक समस्या का निर्माण करता है और lpSolveपैकेज का उपयोग करके इसे हल करता है:

\begin{aligned} m i n & \sum_{\forall x \in V} \sum_{\forall y \in V} A_{x, y} \cdot f_{x, y} \\ s u b j e c t t o : \\ \sum_{x \in V} f_{v, x} - f_{x, v} = 0 & \forall v \in V : v \neq {s, t} \\ \sum_{x \in V} f_{s, x} - f_{x, s} = d \\ \sum_{x \in V} f_{t, x} - f_{x, t} = - d \\ f_{x, b} \leq C_{x, b} & \forall x \in V, \forall y \in V \end{aligned}

$\begin{align} min & \sum_{\forall x \in V}\ \sum_{\forall y \in V} A_{x,y} \cdot f_{x,y} \\ subject\ to : & \\ & \sum_{x \in V} f_{v,x} - f_{x,v} = 0 & \forall v \in V : v \neq \{s,t\} \\ & \sum_{x \in V} f_{s,x} - f_{x,s} = d \\ & \sum_{x \in V} f_{t,x} - f_{x,t} = -d \\ & f_{x,b} \leq C_{x,b} & \forall x \in V,\forall y \in V \end{align}$ कहाँ पे :

$V$ कोने का सेट है
$s$ s स्रोत शीर्ष है
$t$ s लक्ष्य (या सिंक) शीर्ष है
$A_{x,y}$ धार के लिए प्रवाह लागत है x -> y
$f_{x,y}$ x -> yइष्टतम समाधान में बढ़त का प्रवाह है
$d$ सिंक पर आवश्यक प्रवाह है (यानी मांग पर) $t$ और उत्पादन में $s$ )
$C_{x,y}$ बढ़त की अधिकतम क्षमता है x -> y

— digEmAll
स्रोत

अच्छा, लीनियर प्रोग्रामिंग :) दुर्भाग्य से अधिकांश भाषाओं में एक नहीं है lpSolve... :(

— क्विंटेक

यह दुर्भाग्य से सच है ... BTW यह बेस-आर पर उपलब्ध नहीं है, यह एक पैकेज है ... मुझे

— टीआईओ

किसी कारण के लिए मुझे अभी तक MinCostMaxFlow को MinCostFlow बनने के लिए संशोधित करने का एक छोटा तरीका ढूंढना है ... मेरा दिमाग तले हुए है, मैं चाहता हूं कि इसके लिए गणित के अलावा अन्य भाषाओं में भी एक समारोह हो

— क्विंट

@ क्विंट: क्या आप MinCostMaxFlow के एक विशिष्ट कार्यान्वयन (उदाहरण के लिए एक निश्चित भाषा में) की बात कर रहे हैं?

— digEmAll

नहीं, मेरा हाथ कोडित एल्गोरिथ्म

— क्विंटेक

वोल्फ्राम भाषा, 42 बाइट्स

FindMinimumCostFlow[#,1,VertexCount@#,#2]&

तुच्छ बनाया। गैर-निर्मित समाधान जल्द ही आ रहा है।

— lirtosiast
स्रोत

क्या यह 6-8 सप्ताह में आ रहा है? : पी

— क्विंटेक

पायथन 3 + नेटवर्कएक्स , 137 बाइट्स

from networkx import*
def f(g,d,z='demand'):N=len(g)**.5//1;G=DiGraph(g);G.node[0][z]=-d;G.node[N-1][z]=d;return min_cost_flow_cost(G)

कोई ट्रायऑनलाइन लिंक नहीं क्योंकि TIO में नेटवर्कएक्स लाइब्रेरी स्थापित नहीं है

इस तरह की क्षमता और वजन विशेषताओं के साथ एक बढ़त सूची के रूप में ग्राफ इनपुट लेता है:

[(0, 0, {'capacity': 0, 'weight': 0}), (0, 1, {'capacity': 3, 'weight': 1}), (0, 2, {'capacity': 2, 'weight': 1}), (0, 3, {'capacity': 3, 'weight': 2}), (0, 4, {'capacity': 2, 'weight': 1}), (1, 0, {'capacity': 3, 'weight': 1}), (1, 1, {'capacity': 0, 'weight': 0}), (1, 2, {'capacity': 5, 'weight': 1}), (1, 3, {'capacity': 3, 'weight': 2}), (1, 4, {'capacity': 3, 'weight': 3}), (2, 0, {'capacity': 2, 'weight': 1}), (2, 1, {'capacity': 5, 'weight': 1}), (2, 2, {'capacity': 0, 'weight': 0}), (2, 3, {'capacity': 4, 'weight': 2}), (2, 4, {'capacity': 5, 'weight': 2}), (3, 0, {'capacity': 3, 'weight': 2}), (3, 1, {'capacity': 3, 'weight': 2}), (3, 2, {'capacity': 4, 'weight': 2}), (3, 3, {'capacity': 0, 'weight': 0}), (3, 4, {'capacity': 4, 'weight': 3}), (4, 0, {'capacity': 2, 'weight': 1}), (4, 1, {'capacity': 3, 'weight': 3}), (4, 2, {'capacity': 5, 'weight': 2}), (4, 3, {'capacity': 4, 'weight': 3}), (4, 4, {'capacity': 0, 'weight': 0})]

यह कोड का एक गोल्फ संस्करण है जिसे मैंने परीक्षण मामलों को सत्यापित करने के लिए उपयोग किया था।

— मै जाऊं
स्रोत