एक बिट कंटिन्यू करें

Question

आइए कल्पना करें कि हमारे पास बिट्स का एक मैट्रिक्स है (जिसमें कम से कम एक है 1):

0 1 0 1 1 0 1 0 0 1 0
0 1 0 1 0 0 1 0 1 1 0
0 0 1 0 1 1 0 1 0 1 0
1 1 0 0 1 0 0 1 1 0 1
0 0 0 1 0 1 1 0 0 1 0

हम इस मैट्रिक्स में कुछ बिट्स को सेट करना चाहते हैं, जैसे कि यह एस का एक सन्निहित बूँद बनाता है 1, जिसमें प्रत्येक 1प्रत्यक्ष या अप्रत्यक्ष रूप 1से ऑर्थोगोनल आंदोलन के माध्यम से हर दूसरे से जुड़ा होता है :

0 1 1 1 1 1 1 0 0 1 0
0 1 0 1 0 0 1 0 1 1 0
0 1 1 0 1 1 1 1 0 1 0
1 1 0 0 1 0 0 1 1 1 1
0 0 0 1 1 1 1 0 0 1 0

(आप 1अपने ब्राउज़र की "खोज" सुविधा के साथ खोज करके इसे और अधिक स्पष्ट रूप से देख सकते हैं ।)

हालाँकि, हम अपने द्वारा सेट बिट्स की संख्या को भी कम करना चाहते हैं।

काम

बिट्स या बूलियन्स के एक मैट्रिक्स (या सरणियों के सरणी) को देखते हुए, बिट्स की न्यूनतम संख्या लौटाएं जिन्हें 1एस के एक सन्निहित महाद्वीप बनाने के लिए सेट करने की आवश्यकता है । मैट्रिक्स में एक सेट बिट से दूसरे सेट बिट्स के लिए केवल ऑर्थोगोनल दिशा में यात्रा करके संभव होना चाहिए।

यह कोड-गोल्फ है , इसलिए सबसे कम वैध जमा (बाइट्स में मापा गया) जीतता है।

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

0 1 0 1 1 0 1 0 0 1 0
0 1 0 1 0 0 1 0 1 1 0
0 0 1 0 1 1 0 1 0 1 0
1 1 0 0 1 0 0 1 1 0 1
0 0 0 1 0 1 1 0 0 1 0
=> 6

1 0 0 0 0 0 1 0 0
1 1 0 0 1 1 1 0 0
1 1 1 0 1 1 1 1 1
0 1 0 0 0 0 0 0 0
0 0 0 0 0 1 1 1 1
0 1 0 0 0 0 1 1 0
1 0 0 0 0 0 1 0 0
=> 4

0 0 0 1 1 1 0 1 1
0 0 1 0 0 0 0 1 0
0 0 1 1 1 1 1 1 0
1 1 0 0 1 1 0 0 0
0 0 1 1 1 0 0 1 1
0 1 1 1 0 0 0 0 0
1 1 1 0 0 1 1 1 0
1 1 1 0 1 1 0 1 1
0 0 0 0 1 0 0 0 1
1 1 0 0 1 1 0 1 1
0 0 0 0 0 0 0 1 0
0 1 1 1 1 0 0 0 0
0 0 0 1 1 0 0 0 1
0 1 0 0 1 0 1 1 0
0 1 1 1 0 0 0 0 1
=> 8

1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
=> 0

Comments

इसके लिए थोड़ा और समझाने की जरूरत है। एक मैट्रिक्स में एक "सन्निहित बूँद" क्या है?

— NoOneIsHere

चूंकि समस्या को एनपी-हार्ड के रूप में जाना जाता है इसलिए यह सबसे तेज-एल्गोरिथ्म के लिए एक अच्छी समस्या नहीं है ।

— पीटर टेलर

@ पेटर टेलर और एसपी -

— हार्डनेस

पीटर टेलर और हाइपरनेट्रिनो की टिप्पणियों के प्रकाश में, और इस तथ्य पर कि वर्तमान में इस सवाल का कोई जवाब नहीं है, मैं स्कोरिंग विधि को कोड-गोल्फ में बदल रहा हूं ।

— फलन

1मैट्रिक्स में नहीं होने पर हमें क्या करना चाहिए ?

— कोलेरा सु

Answer 1

सी (जीसीसी), 308 306 बाइट्स

फ़ंक्शन fप्राप्त करता है (height, width, flattened array, pointer to ans), और पॉइंटर द्वारा उत्तर देता है।

यदि 1मैट्रिक्स में नहीं है, तो यह वापस आ जाएगा 0।

#define v A[i]
N,M,K,R,C,T,i,*A;s(x,y){i=x*M+y;if(!(x<0|y<0|x>=N|y>=M|v^1))v=2,s(x,y+1),s(x,y-1),s(x+1,y),s(x-1,y);}g(i){if(C<R){if(i^K){g(i+1);if(!v)C+=v=1,g(i+1),v=0,C--;}else{T=1;for(i=0;i<K&&!v;i++);s(i/M,i%M);for(i=0;i<K;i++)T&=v^1,v=!!v;if(T)R=C;}}}f(n,m,a,b)int*a,*b;{K=R=(N=n)*(M=m),A=a;g(0);*b=R;}

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

Ungolfed:

N,M,R,C,T,i,*A; // height, width, result, recursion depth

s(x,y)
{ // depth first search: replace all 1 in the same connected component with 2
    i=x*M+y;
    if(!(x<0|y<0|x>=N|y>=M|A[i]^1)) { // check if out of boundary
        A[i]=2;
        s(x, y+1),s(x, y-1),s(x+1, y),s(x-1, y);
    }
}

g(i)
{ // enumerate all posible solutions
    if(C<R) {
        if(i!=N*M) {
            g(i+1);      // nothing change for this entry
            if (!A[i]) { // set the entry to 1
                C++, A[i]=1;
                g(i+1);
                C--, A[i]=0;
            }
        }
        else {
            T=1;
            for (i=0; i<N*M && !A[i]; i++); // find first non-zero entry
            s(i/M, i%M);     // replace the connected component
            for (i=0; i<N*M; i++) {
                T&=A[i]!=1;   // check if no other components
                A[i]=!!A[i]; // change 2s back to 1
            }
            if (T) R=C;      // update answer
        }
    }
}

f(n,m,a,b)int*a,*b;{
    R=(N=n)*(M=m), A=a;
    g(0);
    *b=R;
}

Answer 2

पायथन 2 , 611 बाइट्स

एक पूर्ण कार्यक्रम जो उपयोगकर्ता इनपुट के माध्यम से सूचियों की सूची लेता है। कार्य Iऔर dसरणी में द्वीपों की संख्या की गणना करते हैं। अंत में लूप के लिए सभी संभावनाओं के माध्यम से जाना जाता है जहां आप 0s को बदल सकते हैं 1तब यदि कोई द्वीप छोड़ दिया 1गया है तो सूची में जोड़े गए s की संख्या C। उस सूची में न्यूनतम किसी भी द्वीप को जोड़ने के लिए आवश्यक न्यूनतम फ़्लिप की संख्या है। यह बहुत धीमा एल्गोरिथम है, इसलिए यह 60 के दशक में दिए गए परीक्षण मामलों को नहीं चलाता है (मैंने अधिक समय तक प्रयास नहीं किया था) लेकिन मैंने कुछ छोटे (~ 5x5) परीक्षण मामलों की कोशिश की और यह सही ढंग से काम कर रहा है। मुझे इस पृष्ठ से द्वीप गणना एल्गोरिथ्म मिला है ।

from itertools import*
def d(g,i,j,v):
 v[i][j],R,C=1,[-1,1,0,0],[0,0,-1,1]
 for k in range(4):
	if len(g)>i+R[k]>=0<=j+C[k]<len(g[0]):
	 if v[i+R[k]][j+C[k]]<1and g[i+R[k]][j+C[k]]:v=d(g,i+R[k],j+C[k],v)
 return v
def I(g):
 w=len(g[0])
 v,c=[w*[0]for r in g],0
 for i in range(len(g)*w):
	if v[i/w][i%w]<1and g[i/w][i%w]>0:v=d(g,i/w,i%w,v);c+=1
 return c           
g=input()
C=[]
for p in [list(t)for t in product([0,1],repeat=sum(r.count(0)for r in g))]:
 h,G,x=0,[r[:]for r in g],len(g[0])
 for i in range(x*len(G)):
	if G[i/x][i%x]<1:h+=p[0];G[i/x][i%x]=p[0];del p[0]
 if I(G)<2:
	C.append(h)
print min(C)

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

कुछ चीजों को अनुकूलित करने से पहले Pregolfed संस्करण:

from itertools import*
def d(g,i,j,v):
    v[i][j]=1
    R=[-1,1,0,0]
    C=[0,0,-1,1]
    for k in range(4):
        if len(g)>i+R[k]>=0<=j+C[k]<len(g[0]):
            if v[i+R[k]][j+C[k]]<1:
                if g[i+R[k]][j+C[k]]:
                    v=d(g,i+R[k],j+C[k],v)
    return v
def I(g):
    w=len(g[0])
    v=[[0]*w for r in g]
    c=0
    for i in range(len(g)):
        for j in range(w):
            if v[i][j]<1and g[i][j]>0:
                v=d(g,i,j,v)
                c+=1
    return c           
g=input()
z=sum(r.count(0)for r in g)
f=[list(t)for t in product('01',repeat=z)]
C=[]
for p in f:
    h=0
    G=[r[:]for r in g]
    x=len(G[0])
    for i in range(x*len(G)):
        exec('h+=int(p[0]);G[i/x][i%x]=int(p[0]);del p[0]'*(G[i/x][i%x]<1))
    if I(G)<2:
        C.append(h)
print min(C)