Localizando o tamanho do menor subconjunto com GCD = 1

10

Este é um problema da sessão de treinos do Concurso Polonês de Programação Colegial de 2012 . Embora eu tenha encontrado as soluções para o concurso principal, não consigo encontrar a solução para esse problema em nenhum lugar.

O problema é: dado um conjunto de números inteiros positivos distintos não maiores que , encontre o tamanho do subconjunto menor que não possui divisor comum além de 1. é no máximo 500 e é possível presumir que existe uma solução . $N$ $10^9$ $m$ $N$

Consegui mostrar que meu número . Meu raciocínio é: Suponha que exista um subconjunto mínimo de tamanho , com gcd = 1. Então todos os 9 subconjuntos de devem ter gcd> 1. Existem exatamente 10 desses subconjuntos e seus gcds devem ser pareados coprime. Seja esses gcds , onde , para . Então o número máximo em é . Mas , uma contradição. $m \le 9$ $S$ $|S|=10$ $S$ $1 < g_1 < g_2 < ... < g_{10}$ $\gcd(g_i,g_j)=1$ $i \neq j$ $S$ $g_2g_3...g_{10}$ $g_2g_3...g_{10} \ge 3\times5\times7\times11\times...\times29=3234846615 > 10^9$

No entanto, mesmo com isso, uma força bruta direta ainda é muito lenta. Alguém tem outras idéias?

algorithms number-theory

— Wakaka
fonte

O que não pode

g_{2} = 2

$g_2 = 2$ ?

— precisa saber é

g_{2} > g_{1} \geq 2

$g_2 > g_1 \ge 2$ .

g_{1}

$g_1$ não pode ser 1, desde 9-subconjuntos não pode ter um GCD de 1.

— Wakaka

1

Esse problema é equivalente ao seguinte e é trivial construir redução nos dois sentidos.

Dada uma lista de vetores de bits, encontre o número mínimo deles para que andtodos resultem no vetor de bits. $0$ $(*)$

Em seguida, mostramos a cobertura do conjunto reduzida para . Por cobertura de conjunto, quero dizer, com uma lista dos conjuntos , encontre o número mínimo de conjuntos que cobre sua união. $(*)$ $S_1,\ldots,S_k$

Ordenamos que os elementos nos conjuntos sejam . Seja , onde se , 0 caso contrário. Note que esta função é uma bijeção e, portanto, tem uma inversa. $a_1,\ldots,a_n$ $f(S) = (1-\chi_{a_1}(S),\ldots,1-\chi_{a_n}(S))$ $\chi_x(S) = 1$ $x\in S$

Agora, se resolvermos em e as soluções forem , então é a solução para se proteger. $(*)$ $f(S_1),\ldots,f(S_k)$ $\{ f(S_{b_1}),\ldots,f(S_{b_m})\}$ $\{ f^{-1}(S_{b_1}),\ldots,f^{-1}(S_{b_m})\}$

Assim, eu pensaria que esse problema está testando a capacidade de podar o espaço de pesquisa.

— Chao Xu
fonte

Como você encontra a cobertura mínima de vértices?

— Yuval Filmus 8/03/2013

oh, nvm esta solução, está definida como cobertura.

— Chao Xu

11

Isso é verdade, mas acho que talvez possamos explorar certas propriedades desse caso especial. Por exemplo, neste caso, os conjuntos são todos muito grandes, com tamanhos não inferiores a . De fato, se os números nos conjuntos forem todos pequenos, seus tamanhos serão ainda maiores. Além disso, podemos encontrar definitivamente 9 conjuntos que cobrem tudo. De qualquer forma, como você sugere que eu apare o espaço de pesquisa?

n - 9

$n-9$

— Wakaka 14/03

Não vejo como o problema (*) é equivalente ao dado na pergunta. Por um lado, o problema dado na pergunta tem a promessa de que todos os números inteiros serão , o que corresponde a uma garantia sobre os pesos dos vetores de bits que não aparecem no problema (*).

\leq 10^{9}

$\le 10^9$

— DW

1

É possível resolver isso de forma relativamente eficiente, computando todos os MDCs em pares, removendo duplicatas e recorrendo novamente. É o ato de remover duplicatas antes de você recursar que a torna eficiente.

Vou explicar o algoritmo com mais detalhes abaixo, mas primeiro, ele ajuda a definir um operador binário . Se são conjuntos de números inteiros positivos, defina $\otimes$ $S,T$

S \otimes T = {gcd (s, t) : s \in S, t \in T} .

$S \otimes T = \{\gcd(s,t) : s \in S, t \in T\}.$

Observe quee (no seu problema); normalmente, será ainda menor do que qualquer um desses limites sugere, o que ajuda a tornar o algoritmo eficiente. Observe também que podemos calcular comoperações gcd por enumeração simples. $|S \otimes T| \le |S| \times |T|$ $|S \otimes T| \le 10^9$ $S \otimes T$ $S \otimes T$ $|S| \times |T|$

Com essa notação, aqui está o algoritmo. Seja o conjunto de números de entrada. Calcule , depois , depois e assim por diante. Encontre o menor tal que mas . Então você sabe que o tamanho do menor subconjunto é . Se você também deseja apresentar um exemplo concreto de um subconjunto, mantendo os ponteiros de retorno, é possível reconstruir facilmente esse conjunto. $S_1$ $S_2 = S_1 \otimes S_1$ $S_3 = S_1 \otimes S_2$ $S_4 = S_1 \otimes S_3$ $k$ $1 \in S_k$ $1 \notin S_{k-1}$ $k$

Isso será relativamente eficiente, pois nenhum dos conjuntos intermediários aumenta em tamanho acima de (na verdade, seu tamanho provavelmente será muito menor que isso) e o tempo de execução requer cerca de operações gcd. $10^9$ $500 \times (|S_1| + |S_2| + \cdots)$

Aqui está uma otimização que pode melhorar ainda mais a eficiência. Basicamente, você pode usar a duplicação iterada para encontrar o menor tal que . Em particular, para cada elemento , acompanhamos o menor subconjunto de cujo gcd é e cujo tamanho é . (Ao remover duplicatas, você resolve laços em favor do subconjunto menor.) Agora, em vez de calcular a sequência de nove conjuntos , calculamos a sequência de cinco conjuntos , calculando , depois , em seguida, $k$ $1 \in S_k$ $x \in S_i$ $S_1$ $x$ $\le i$ $S_1,S_2,S_3,S_4,\dots,S_9$ $S_1,S_2,S_4,S_8,S_9$ $S_2 = S_1 \otimes S_1$ $S_4 = S_2 \otimes S_2$ $S_8 = S_4 \otimes S_4$ , então . À medida que avança, encontre o primeiro modo que . Depois de encontrar como , é possível parar imediatamente: você pode encontrar o menor subconjunto cujo gcd é observando o subconjunto associado a . Portanto, você pode parar assim que atingir um conjunto tal que , o que permite que você pare mais cedo se encontrar um subconjunto menor. $S_9 = S_1 \times S_8$ $k \in [1,2,4,8,9]$ $1 \in S_k$ $k$ $1 \in S_k$ $1$ $1$ $S_k$ $1 \in S_k$

Isso deve ser eficiente em termos de tempo e espaço. Para economizar espaço, para cada elemento , você não precisa armazenar o conjunto inteiro: basta armazenar dois ponteiros traseiros (os dois elementos de quais você tirou o MDC, para obter ) e opcionalmente, o tamanho do subconjunto correspondente. $x \in S_k$ $S_i,S_j$ $x$

Em princípio, você pode substituir a sequência por qualquer outra cadeia de adição . Não sei se alguma outra cadeia de adição será melhor. A escolha ideal pode depender da distribuição de respostas corretas e dos tamanhos esperados dos conjuntos , o que não está claro para mim, mas provavelmente pode ser derivado empiricamente através da experimentação. $[1,2,4,8,9]$ $S_k$

Créditos: Meus agradecimentos ao KWillets pela idéia de armazenar um subconjunto de números junto com cada elemento de , o que permite parar mais cedo. $S_i$

— DW
fonte

Eu acredito que a pesquisa binária não é necessária; você pode armazenar a contagem de elementos com cada gcd e configurá-la para a soma mínima de pares durante cada duplicação.

— KWillets

Ótimo ponto, @KWillets! Obrigado por essa bela ideia! Eu o incorporei na minha resposta.

— DW

0

Talvez seja mais rápido analisar isso de outra maneira ... o maior número primo menor que é 31607, para uma contagem total de 3401 números primos entre 2 e 31607, não um número muito grande. Escreva cada um dos números que você recebe totalmente fatorado nos números primos até 31607: Aqui é 1 ou um número primo grande. Então, um conjunto de 's é relativamente primo se os vetores correspondentes forem linearmente independentes (e seus forem diferentes ou ambos 1), e você estiver procurando a classificação de uma matriz. $\sqrt{10^9}$

a_{i} = p_{1}^{n_{i 1}} p_{2}^{n_{i 2}} \dots P_{i}

$a_i = p_1^{n_{i 1}} p_2^{n_{i 2}} \ldots P_i$

P_{i}

$P_i$

a_{i}

$a_i$

n_{i j}

$n_{i j}$

P

$P$

— vonbrand
fonte

Qual é a conexão com a independência linear? Os vetores e são linearmente independentes, mas o MDC é enquanto queremos .

(1, 1)

$(1,1)$

(1, 0)

$(1,0)$

(1, 0)

$(1,0)$

(0, 0)

$(0,0)$

— Yuval Filmus

11

A independência linear não parece funcionar, mas podemos usar essa decomposição principal de uma maneira diferente. Para cada primo (entre 'e no máximo '), defina o conjunto como a coleção de todos os números (entre o conjunto fornecido) que não têm como fator. O problema agora é encontrar um menor subconjunto de números que, para cada , . Esse é o problema do conjunto de batidas, equivalente ao problema da tampa do conjunto. Este é um completo, mas pode haver algumas implementações rápidas o suficiente para esse tamanho.

p

$p$

3401

$3401$

p_{i}

$p_i$

500

$500$

P_{i}

$P_i$

A_{p}

$A_p$

p

$p$

B

$B$

A_{p}

$A_p$

| A_{p} \cap B | \geq 1

$|A_p \cap B| \geq 1$

N P

$NP$

— Polkjh 7/03

Você poderia me direcionar para algumas implementações que poderiam funcionar? Até agora, só consigo encontrar algoritmos de aproximação. Obrigado!

— Wakaka 14/03

Este documento de pesquisa analisa as soluções aproximadas e exatas. E ao responder a um comentário, adicione @ nome da pessoa ao comentário. Enviará uma notificação para essa pessoa. Caso contrário, eles talvez nunca saibam sobre o seu comentário.

— Polkjh

-1

Se você é capaz de encontrar um subconjunto com gcd (S) = 1, sempre posso remover elementos redundantes do subconjunto até restarem apenas 2 elementos, que possuem gcd (S) = 1. Portanto, posso afirmar que o menor subconjunto conterá 2 elementos ou ele não existirá.

Agora, usamos recursão para resolver esse problema. Vamos dividir a matriz de números em 2 partes, uma com n-1 elementos e outra com 1 elemento (último elemento). Os 2 números estarão nos primeiros elementos n-1 ou um elemento estará presente na 1ª parte emparelhado com o último elemento. Portanto, somos capazes de resolver esse problema em

T (n) = T (n-1) + O (n) tempo. o que significa T (n) = O (n ^ 2).

— Pratik
fonte

4

gcd (6, 10, 15) = 1

$\gcd(6,10,15)=1$ . Qual elemento você pode remover?

— 21415 Rick Decker