Você é fazendeiro e seu rebanho de ovelhas escapou! Ah não!

Junte essas ovelhas construindo cercas para contê-las. Como agricultor com orçamento limitado, você deseja usar a menor quantidade possível de cercas. Felizmente para você, elas não são as ovelhas mais inteligentes do mundo e não se incomodam em se mover depois de terem escapado.

Tarefa

Dada uma lista de coordenadas, produza a menor quantidade de segmentos de cerca necessária para conter as ovelhas.

Regras

• Ovelhas são contidas se não puderem se afastar (sem buracos na cerca).
• Você não precisa conter todas as ovelhas em um bloco de cerca - pode haver várias áreas cercadas, independentes umas das outras.
• Os segmentos de vedação são orientados em direções cardinais.
• Cada tupla de coordenadas representa uma única ovelha.
• A entrada deve ser pares inteiros positivos, x>0& y>0, mas pode ser formatada adequadamente para o seu idioma.
  • ou seja: {{1,1},{2,1},{3,7}, .. }ou[1,2],[2,1],[3,7], ..
• Espaços vazios dentro de uma área cercada são aceitáveis.
• Você não pode assumir que as coordenadas são inseridas em qualquer ordem específica.

Por exemplo, uma única ovelha exige que os 4segmentos da cerca estejam totalmente contidos.

Casos de teste

[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

Notas

• Você pode assumir que as coordenadas de entrada são válidas.
• Teoricamente, seu algoritmo deve funcionar para qualquer coordenada inteira razoavelmente grande (até o valor máximo suportado do seu idioma).
• As respostas completas do programa ou da função estão corretas.

Isso é código-golfe , então a resposta mais curta em bytes vence!

JavaScript (ES6), 251 244 275 bytes

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

Quão?

Usamos a função recursiva P () para criar uma lista de todas as partições possíveis da lista de entrada. Atualmente, esta função está abaixo do ideal, pois está retornando algumas partições duplicadas - o que não altera o resultado final.

Para cada partição, calculamos o número de cercas necessárias para cercar todas as ovelhas em cada grupo com um retângulo. A soma dessas cercas fornece a pontuação da partição. Eventualmente, retornamos a pontuação mais baixa.

Casos de teste

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 bytes

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

Experimente online!