Número de multisets de modo que cada número de 1 a

Meu problema. Dada $n$ , quero contar o número de válido multisets $S$ . Um multiset $S$ é válido se

A soma dos elementos de $S$ é $n$ , e
Cada número de $1$ a $n$ pode ser expressa de forma única como uma soma de alguns dos elementos de $S$ .

Exemplo. Por exemplo, se $n=5$ , $\{1,1,1,1,1\}, \{1,2,2\}, \{1,1,3\}$ são válidos.

No entanto, $S=\{1,1,1,2\}$ é inválido porque 2 pode ser formado por $\{1,1\}$ e $\{2\}$ (ou seja, 2 pode ser expresso como $2=1+1$ e $2=2$ ) , portanto, a segunda condição não é válida. Da mesma forma 3 pode ser formado por $\{2,1\}$ e $\{1,1,1\}$ .

$S=\{1,2,4$ } também é inválido porque todos os números de $1$ a $5$ podem ser feitos exclusivamente, mas a soma dos elementos de $S$ não é $5$ .

Eu tentei encontrar um bom algoritmo para esse problema por algum tempo, mas não consigo resolvê-lo. É de codechef . Eu já vi algumas das soluções enviadas, mas ainda não consegui obter a lógica para resolver o problema. NOTA: O limite de tempo para a pergunta é de 10 segundos e $n<10^9$

Para um multiset, usarei a notação $S = \{(a_1, c_1), (a_2, c_2) ... \}$ $a_i<a_j$ se $i<j$ , o que significa $a_i$ ocorre $c_i$ vezes na multiconjunto S.

Até agora eu tirei algumas conclusões

O primeiro elemento do multiset classificado necessário deve ser $1$
Seja é um conjunto seguindo as duas propriedades, então $S=\{1,a_2 \cdots a_k\} | a_1 \leq a_2\cdots \leq a_k$ $\forall r<k \ \ a_{r+1} = a_r \text{ or } (\sum_{i=0}^ra_i) + 1$
Seja , onde ocorre vezes, segue as propriedades necessárias e, a partir da conclusão acima, podemos dizer que e $S=\{(1,c_1),(a_2,c_2) \cdots (a_k,c_k)\} | a_1 \leq a_2\cdots \leq a_k$ $a_i$ $c_i$ $\forall i \ a_i|n+1$ se . Prova: $a_i | a_j$ $j > i$
$a_{i+1} = (a_ic_i + a_i -1 ) + 1 \Rightarrow a_i | a_{i+1}$
Agora, considere ou seja, todo o os números subseqüentes após 1 serão múltiplos de . Então vamos $S=\{ \underbrace{1,1 \cdots 1}_{d-1},d,d \cdots d,dm_1, dm_1 \cdots dm_1,dm_2, dm_2 \cdots dm_2, \cdots \}$ $d$ $f(n)$ seja possível a contagem desse multiset, então onde estou somando todo o número possível de(). Em outros termos $f(n) = \sum_{d|n+1, d\neq 1} f(\frac{n-(d-1)}{d})$ $1's$ $=d-1$ $f(n-1)=g(n)=\sum_{d|n,d \neq n}g(d)$

Finalmente, meu problema é reduzido a isso - encontre maneira eficiente para que não exceda o limite de tempo. $g(n)$

algorithms integers

— Liga da Justiça
fonte

Você verificou se é apropriado solicitar que outras pessoas publiquem publicamente soluções e algoritmos para problemas práticos? O FAQ do Codechef parece esperar que as soluções não sejam publicadas publicamente (exceto por alguns problemas muito básicos). A publicação de uma solução aqui estaria "estragando" os problemas da prática para os outros, ou isso é considerado bom? Não estou familiarizado com as normas e a etiqueta da comunidade de Codechef.

— DW

Não encontrei nada relacionado a não postar perguntas no domínio público nas perguntas frequentes e essa restrição está nos problemas contínuos do concurso e não no problema da prática.

— liga da justiça

@DW Eu não acho que eles se importariam se discutíssemos prblems que não são de concursos em andamento.

— Ravi Upadhyay

Você está procurando o número de partições do número de entrada. Eu sugiro que você faça alguma pesquisa usando esse chavão.

— Raphael

@ Rafael, eu concordo, o pôster deve ler sobre essas técnicas. Não é exatamente o mesmo problema - a primeira condição do pôster exige que seja uma partição, mas a segunda condição impõe restrições adicionais (para alterações exclusivas ) - mas pode ser possível aplicar as mesmas técnicas usadas para contar o número de partições, com algumas modificações para lidar com o requisito adicional.

— DW

Respostas:

Aqui está o que a solução mais rápida está fazendo. Na verdade, está computando sua função Dado , nós o fatoramos (veja abaixo) e depois calculamos todos os fatores (veja abaixo) em alguma ordem tal que implica (propriedade P). Agora calculamos acordo com a fórmula, revisando os fatores na ordem dada. A propriedade P garante que, quando calculamos , já calculamos para todos os fatores não triviais

g (n) = \sum_{\begin{matrix} d ∣ n \\ d < n \end{matrix}} g (d), g (1) = 1.

$g(n) = \sum_{\substack{d \mid n \\ d < n}} g(d), \quad g(1) = 1.$

n

$n$

f_{1}, \dots, f_{m}

$f_1,\ldots,f_m$

f_{i} | f_{j}

$f_i|f_j$

i \leq j

$i \leq j$

g

$g$

g (d)

$g(d)$

g (e)

$g(e)$

e

$e$ de

. Há também uma otimização (veja abaixo).

d

$d$

Mais detalhadamente, examinamos os fatores em ordem e, para cada fator , encontramos todos os seus fatores não triviais, verificando qual de divide . $f_i$ $f_1,\ldots,f_{i-1}$ $f_i$

Factoring: Pré - processamento: fazemos uma lista de todos os números primos abaixo de usando a peneira de Eratóstenes. Dado , simplesmente usamos a divisão de teste. $10^9$ $n$

Gerando todos os fatores: isso é feito recursivamente. Suponha que . Executamos loops aninhados e produzimos . Você pode provar a propriedade P por indução. $n = p_1^{k_1} \cdots p_t^{k_t}$ $t$ $l_1 \in \{0,\ldots,k_1\},\ldots,l_t \in \{0,\ldots,k_t\}$ $p_1^{l_1}\cdots p_t^{l_t}$

Otimização: Como o programa é executado em várias entradas, podemos usar a memorização para economizar tempo em diferentes entradas. Memorizamos apenas valores pequenos (até ), e isso nos permite armazenar todos os valores memorizados em uma matriz. A matriz é inicializada com zeros e, portanto, podemos dizer quais valores já são conhecidos (já que todos os valores calculados são positivos). $10^5$

Se a fatoração primária de for , então depende apenas de e, de fato, apenas da versão classificada desse vetor . Todo número abaixo de tem no máximo fatores primos (com repetição) e, como , parece possível calcular $n+1$ $p_1^{k_1},\ldots,p_t^{k_t}$ $f(n)$ $(k_1,\ldots,k_t)$ $10^9$ $29$ $p(29)=4565$ $f$ (ou melhor, ) para todos eles, recursivamente. Essa solução poderia ser mais rápida se houvesse muitas entradas diferentes; como é, existem no máximo . $g$ $10$

Também é possível que essa função, mapeando partições para o correspondente , tenha uma forma analítica explícita. Por exemplo, , é dado por A000670 e é dado por A005649 ou A172109 . $g$ $g(p^k) = 2^{k-1}$ $g(p_1\ldots p_t)$ $g(p_1^2 p_2\ldots p_t)$

— Yuval Filmus
fonte

OK, então você tem uma relação de recorrência para (consulte o final de sua pergunta). $g(\cdot)$

Nesse ponto, parece que uma abordagem natural seria escrever o algoritmo recursivo para calcular e aplicar a memorização para não computar mais de uma vez. Em outras palavras, quando você calcula , armazena-o em uma tabela de hash que mapeia ; se precisar conhecer novamente no futuro, procure-o na tabela de hash. $g(n)$ $g(i)$ $g(i)$ $i \mapsto g(i)$ $g(i)$

$n$ $n$ $n\le 10^9$

$g(1),g(2),g(3),g(4),g(5),\ldots$

— DW
fonte

Aqui está uma dica para você começar. Aplique algoritmos de programação dinâmica padrão para enumerar o conjunto de partições de um número inteiro e adicione alguma lógica para verificar qual delas permite a realização de alterações exclusivas, verificando iterativamente todas as somas, fazendo alterações e verificando a exclusividade.

$S$ $i$ $1 \le i \le n$ $S$ $i$

$S$ $n$ $S$

$P(n)$ $P(1), P(2), \dots, P(n)$ $P(n+1)$

Aqui está uma abordagem que provavelmente será melhor.

$S$ $n$ $T$ $S$ $T$ $n'$

$x$ $S$ $S$ $T$ $x$ $S$ $S$ $T$ $n$

$S$ $A[1\ldots |S|,1 \ldots n]$ $A[i,j]$ $j$ $i$ $S$ $i$ $S$ $S$ $S=\{s_1,s_2,\dots,s_k\}$ $s_1\le s_2 \le \cdots \le s_k$ $A[i,j]$ $A[1\ldots i-1, 1\ldots j-1]$ $A[i,j] = A[i-1,j] \lor A[i-1,j-s_i]$ $j>s_i$ $A[i,j]=A[i-1,j]$ $S$

$T$ $S$ $S$ $T$ $n$ $S$ $n'$ $T$ $n+1,n+2,\ldots,n'$ $T$ $A$ $A[1\ldots |T|, 1 \ldots n']$ $A[|T|,n+1], A[|T|,n+2], \ldots, A[|T|,n']$ $T$ $S$

$S$ $n$ $n\le 20$ $P[1\ldots 20]$ $P[5]$ $S$ $P[n]$ $S$ $n$

$P[n]$ $P[1]$ $\{1\}$ $n$ $S \in P[n]$ $T$ $S$ $n'$ $T$ $T$ $P[n']$ $n' \le 20$

Isso deve ser bem factível. Boa sorte! Diverta-se! Trabalhar com os detalhes será um bom exercício de aprendizado em programação dinâmica.

— DW
fonte

n

$n$