Vous êtes agriculteur et votre troupeau de moutons s'est échappé! Oh non!

Rassemblez ces moutons en construisant des clôtures pour les contenir. En tant qu'agriculteur avec un budget limité, vous souhaitez utiliser le moins de clôture possible. Heureusement pour vous, ce ne sont pas les moutons les plus intelligents du monde et ne vous embêtez pas à bouger après vous être échappé.

Tâche

Étant donné une liste de coordonnées, sortez le moins de segments de clôture nécessaires pour contenir les moutons.

Règles

• Les moutons sont confinés s'ils ne peuvent pas s'éloigner (pas de trous dans la clôture).
• Vous n'avez pas à contenir tous les moutons dans un seul bloc de clôture - il pourrait y avoir plusieurs zones clôturées indépendantes les unes des autres.
• Les segments de clôture sont orientés dans des directions cardinales.
• Chaque tuple de coordonnées représente un seul mouton.
• L'entrée doit être des paires entières positives, x>0& y>0, mais peut être formatée de manière appropriée pour votre langue.
  • c'est-à-dire: {{1,1},{2,1},{3,7}, .. }ou[1,2],[2,1],[3,7], ..
• Les espaces vides à l'intérieur d'une zone clôturée sont acceptables.
• Vous ne pouvez pas supposer que les coordonnées sont entrées dans un ordre spécifique.

Par exemple, un seul mouton nécessite que 4les segments de clôture soient entièrement contenus.

Cas de 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

Remarques

• Vous pouvez supposer que les coordonnées d'entrée sont valides.
• Votre algorithme devrait théoriquement fonctionner pour toute coordonnée d'entier raisonnablement grande (jusqu'à la valeur maximale prise en charge de votre langue).
• Les réponses complètes au programme ou aux fonctions sont correctes.

C'est le golf de code , donc la réponse la plus courte en octets gagne!

JavaScript (ES6), 251 244 275 octets

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

Comment?

Nous utilisons la fonction récursive P () pour créer une liste de toutes les partitions possibles de la liste d'entrée. Cette fonction est actuellement sous-optimale, car elle renvoie des partitions dupliquées - ce qui ne modifie cependant pas le résultat final.

Pour chaque partition, nous calculons le nombre de clôtures nécessaires pour entourer tous les moutons de chaque groupe d'un rectangle. La somme de ces clôtures donne le score de la partition. Nous retournons finalement le score le plus bas.

Cas de 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 octets

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

Essayez-le en ligne!