Sei un contadino e il tuo gregge di pecore è fuggito! Oh no!

Arrotonda quelle pecore costruendo recinti per contenerle. Come agricoltore con un budget che desideri utilizzare la minima quantità di recinzione possibile. Fortunatamente per te, però, non sono le pecore più intelligenti del mondo e non si preoccupano di muoversi dopo essere fuggite.

Compito

Dato un elenco di coordinate, genera il minor numero di segmenti di recinzione necessari per contenere le pecore.

Regole

• Le pecore sono contenute se non riescono ad allontanarsi (senza buchi nella recinzione).
• Non è necessario contenere tutte le pecore in un blocco di recinzione: potrebbero esserci più aree recintate indipendenti l'una dall'altra.
• I segmenti di recinzione sono orientati in direzioni cardinali.
• Ogni tupla di coordinate rappresenta una singola pecora.
• L'input deve essere coppie di numeri interi positivi, x>0& y>0, ma può essere formattato in modo appropriato per la tua lingua.
  • cioè: {{1,1},{2,1},{3,7}, .. }o[1,2],[2,1],[3,7], ..
• Gli spazi vuoti all'interno di un'area recintata vanno bene.
• Non puoi presumere che le coordinate siano inserite in un ordine specifico.

Ad esempio, una singola pecora richiede che i 4segmenti di recinzione siano completamente contenuti.

Casi test

[1,1]
4

[1,1],[1,2],[2,2]
8

[2,1],[3,1],[2,3],[1,1],[1,3],[3,2],[1,2],[3,3]
12

[1,1],[1,2],[2,2],[3,7],[4,9],[4,10],[4,11],[5,10]
22

[1,1],[2,2],[3,3],[4,4],[5,5],[6,6],[7,7],[8,8],[9,9]
36

[1,1],[2,2],[3,3],[4,4],[6,6],[7,7],[8,8],[9,9]
32

[2,1],[8,3],[8,4]
10

Appunti

• Puoi presumere che le coordinate di input siano valide.
• Il tuo algoritmo dovrebbe teoricamente funzionare per qualsiasi coordinata intera ragionevolmente grande (fino al valore massimo supportato dalla tua lingua).
• Le risposte complete al programma o alla funzione sono a posto.

Questo è code-golf , quindi vince la risposta più breve in byte!

JavaScript (ES6), 251 244 275 byte

a=>Math.min(...(P=(a,r=[[a]],c=a[0])=>(a[1]&&P(a.slice(1)).map(l=>(r.push([[c],...l]),l.map((_,i)=>r.push([[c,...l[i]],...((b=[...l]).splice(i,1),b)])))),r))(a).map(L=>L.reduce((p,l)=>l.map(([h,v])=>(x=h<x?h:x,X=h<X?X:h,y=v<y?v:y,Y=v<Y?Y:v),x=y=1/0,X=Y=0)&&p+X-x+Y-y+2,0)))*2

Come?

Usiamo la funzione ricorsiva P () per creare un elenco di tutte le possibili partizioni dell'elenco di input. Questa funzione è attualmente non ottimale, in quanto restituisce alcune partizioni duplicate, che tuttavia non altera il risultato finale.

Per ogni partizione, calcoliamo il numero di recinti necessari per circondare tutte le pecore in ciascun gruppo con un rettangolo. La somma di questi recinti fornisce il punteggio della partizione. Alla fine restituiamo il punteggio più basso.

Casi test

let f =

a=>Math.min(...(P=(a,r=[[a]],c=a[0])=>(a[1]&&P(a.slice(1)).map(l=>(r.push([[c],...l]),l.map((_,i)=>r.push([[c,...l[i]],...((b=[...l]).splice(i,1),b)])))),r))(a).map(L=>L.reduce((p,l)=>l.map(([h,v])=>(x=h<x?h:x,X=h<X?X:h,y=v<y?v:y,Y=v<Y?Y:v),x=y=1/0,X=Y=0)&&p+X-x+Y-y+2,0)))*2

console.log(f([[1,1]]))
console.log(f([[1,1],[1,2],[2,2]]))
console.log(f([[2,1],[3,1],[2,3],[1,1],[1,3],[3,2],[1,2],[3,3]]))
console.log(f([[1,1],[1,2],[2,2],[3,7],[4,9],[4,10],[4,11],[5,10]]))
console.log(f([[1,1],[2,2],[3,3],[4,4],[5,5],[6,6],[7,7],[8,8],[9,9]]))
console.log(f([[1,1],[2,2],[3,3],[4,4],[6,6],[7,7],[8,8],[9,9]]))
console.log(f([[2,1],[8,3],[8,4]]))

k , 62 58 57 55 byte

{+//2*1+{(|/x)-&/x}'(x@?(&|/2>(|/'{x|-x}x-\:)')')/,:'x}

Provalo online!