Trouver la taille du plus petit sous-ensemble avec GCD = 1

10

Il s'agit d'un problème de la session de pratique du Polish Collegiate Programming Contest 2012 . Bien que je puisse trouver les solutions pour le concours principal, je n'arrive pas à trouver la solution à ce problème n'importe où.

Le problème est le suivant: étant donné un ensemble de entiers positifs distincts ne dépassant pas , trouvez la taille du plus petit sous-ensemble qui n'a pas de diviseur commun autre que 1. est au plus 500, et une solution peut être supposée exister. $N$ $10^9$ $m$ $N$

J'ai réussi à montrer que . Mon raisonnement est le suivant: supposons qu'il existe un sous-ensemble minimal de taille , avec gcd = 1. Alors tous les 9 sous-ensembles de doivent avoir gcd> 1. Il y a exactement 10 de ces sous-ensembles, et leurs gcd doivent être coprime par paire. Que ces pgcd soient , où , pour $m \le 9$ $S$ $|S|=10$ $S$ $1 < g_1 < g_2 < ... < g_{10}$ $\gcd(g_i,g_j)=1$ . Alors le nombre maximum dans est . Mais , une contradiction. $i \neq j$ $S$ $g_2g_3...g_{10}$ $g_2g_3...g_{10} \ge 3\times5\times7\times11\times...\times29=3234846615 > 10^9$

Cependant, même avec cela, une force brute simple est encore trop lente. Quelqu'un a-t-il d'autres idées?

algorithms number-theory

— Wakaka
source

Pourquoi ne peut-on pas

?

g_{2} = 2

$g_2 = 2$

— vonbrand

.

ne peut pas être 1, car 9 sous-ensembles ne peuvent pas avoir un pgcd de 1.

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

$g_2 > g_1 \ge 2$

g_{1}

$g_1$

— Wakaka

1

Ce problème est équivalent au suivant, et il est trivial de construire une réduction dans les deux sens.

Étant donné une liste de vecteurs de bits, trouvez le nombre minimum d'entre eux de telle sorte que andtous résultent du vecteur de bit. $0$ $(*)$

Ensuite, nous montrons que la couverture d'ensemble est réduite à . Par ensemble de couvertures, je veux dire étant donné une liste d'ensembles , trouver le nombre minimum d'ensembles qui couvre leur union. $(*)$ $S_1,\ldots,S_k$

Nous ordonnons que les éléments des ensembles soient . Soit , où si , 0 sinon. Notez que cette fonction est une bijection donc elle a un inverse. $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$

Maintenant, si nous résolvons sur , et que les solutions sont , alors $(*)$ $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})\}$ est la solution pour définir la couverture.

Ainsi, je pense que ce problème teste sa capacité à tailler l'espace de recherche.

— Chao Xu
source

Comment trouvez-vous la couverture minimale des sommets?

— Yuval Filmus

oh nvm cette solution, il est à la place.

— Chao Xu

1

C'est vrai, mais je pense que nous pouvons peut-être exploiter certaines propriétés de ce cas particulier. Par exemple, dans ce cas, les ensembles sont tous très énormes, avec des tailles non inférieures à

. En fait, si les nombres dans les ensembles sont tous petits, leurs tailles seraient encore plus grandes. De plus, nous pouvons certainement trouver 9 ensembles qui couvrent tout. Quoi qu'il en soit, comment proposez-vous que je taille l'espace de recherche?

n - 9

$n-9$

— Wakaka

Je ne vois pas comment le problème (*) est équivalent à celui donné dans la question. D'une part, le problème donné dans la question a la promesse que tous les entiers seront

, ce qui correspond à une garantie sur les poids des vecteurs de bits qui n'apparaissent pas dans le problème (*).

\leq 10^{9}

$\le 10^9$

— DW

1

Il est possible de résoudre ce problème de manière relativement efficace en calculant tous les gcd par paire, en supprimant les doublons, puis en répétant. C'est le fait de supprimer les doublons avant de récurer qui le rend efficace.

$\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\}.$

$|S \otimes T| \le |S| \times |T|$ $|S \otimes T| \le 10^9$ $S \otimes T$ $S \otimes T$ $|S| \times |T|$

$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$ . Si vous souhaitez également générer un exemple concret d'un tel sous-ensemble, en conservant des pointeurs en arrière, vous pouvez facilement reconstruire un tel ensemble.

$10^9$ $500 \times (|S_1| + |S_2| + \cdots)$

$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$ $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$

$x \in S_k$ $S_i,S_j$ $x$

$[1,2,4,8,9]$ $S_k$

$S_i$

— DW
source

Je crois que la recherche binaire n'est pas nécessaire; vous pouvez stocker le nombre d'éléments avec chaque gcd et le régler sur la somme minimale de paires lors de chaque doublage.

— KWillets

Grand point, @KWillets! Merci pour cette belle idée! Je l'ai intégré à ma réponse.

— DW

0

$\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
source

(1, 1)

$(1,1)$

(1, 0)

$(1,0)$

(1, 0)

$(1,0)$

(0, 0)

$(0,0)$

1

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$ -complet, mais il peut y avoir des implémentations assez rapides pour cette taille.

— polkjh

Pourriez-vous me diriger vers certaines implémentations qui pourraient fonctionner? Jusqu'à présent, je ne trouve que des algorithmes d'approximation. Merci!

— Wakaka

Ce document d'enquête examine à la fois les solutions approximatives et exactes. Et lorsque vous répondez à un commentaire, veuillez ajouter @ nom-de-personne au commentaire. Il enverra une notification à cette personne. Sinon, ils ne connaîtront peut-être même pas votre commentaire.

— polkjh

-1

Si vous pouvez trouver un sous-ensemble avec gcd (S) = 1, alors je peux toujours supprimer les éléments redondants du sous-ensemble jusqu'à ce qu'il ne reste que 2 éléments, qui ont gcd (S) = 1. Par conséquent, je peux affirmer que soit le plus petit le sous-ensemble contiendra 2 éléments ou il n'existera pas.

Maintenant, nous utilisons la récursivité pour résoudre ce problème. Divisons le tableau de nombres en 2 parties, une avec n-1 éléments et une avec 1 élément (dernier élément). Soit les 2 nombres seront dans les n-1 premiers éléments, soit un élément sera présent à partir de la 1ère partie appariée avec le dernier élément. Par conséquent, nous sommes en mesure de résoudre ce problème en

T (n) = temps T (n-1) + O (n). ce qui signifie T (n) = O (n ^ 2).

— Pratik
source

4

gcd (6, 10, 15) = 1

$\gcd(6,10,15)=1$