Recolorindo gráficos bipartidos

Dado um gráfico bipartido onde cada vértice é colorido em vermelho ou azul, estou tentando minimizar o número de vértices azuis usando a seguinte operação:$G = (A,B,E)$

1. Escolha um vértice em$v_a$$A$
2. Inverta as cores de , o que significa que e todos os vizinhos de mudarão de cor.$N[v_a]$$v_a$$v_a$

Existe um algoritmo de tempo polinomial para selecionar um conjunto de recoloração que minimize o número de vértices azuis? O número de recolorações necessárias não é relevante.$X \subseteq A$

Observe que a ordem do lançamento não importa e, para cada vértice em , você o vira ou não. Podemos pensar nas cores como um número que é incrementado no módulo 2. Isso gera um algoritmo trivial .$A$$O(2^{|A|} \cdot n)$

O problema é NP-completo e, portanto, não é provável que admita um algoritmo de tempo polinomial. Abaixo está uma prova da completude da NP do problema, mostrada por uma redução de 1 em 3-SAT.

Seja uma instância de 1-IN-3-SAT, em que recebemos uma fórmula 3-CNF-SAT solicitada a encontrar uma atribuição satisfatória em que cada cláusula seja satisfeita por exatamente um literal. Seja o conjunto de variáveis ​​e o conjunto de cláusulas .$\phi$$V(\phi)$$n$$C(\phi)$$m$

Construímos uma instância com um orçamento de (o número permitido de vértices azuis).$G = (A,B,E)$$b = n + m$

Para cada variável , construir dois vértices vermelhos e em em conjunto com vértices azuis em adjacentes a ambos. Isso força exatamente um de ou a ser invertido. Também terminamos com "vértices variáveis" invertidos, usando assim a primeira parte do orçamento.$x \in V(\phi)$$v_x$$v_{\overline{x}}$$A$$b+1$$B$$v_x$$v_{\overline{x}}$$n$

Observação: são as únicas em vértices .$\{v_x, v_{\overline{x}} \mid x \in V(\phi)\}$$A$

Para cada cláusula, digamos , criamos vértices azuis e três vértices vermelhos extras , todas em . Seja todos totalmente adjacentes aos vértices azuis e conecte a , a , e a .$c = x \lor \overline{y} \lor z$$b+1$$v_{x \in c},v_{\overline{y} \in c},v_{z \in c}$$B$$v_x,v_{\overline{y}},v_z$$b+1$$v_x$$v_{x \in c}$$v_y$$v_{\overline{y} \in c}$$v_z$$v_{z \in c}$

Agora, como cada gadget de cláusula tem vértices azuis, sabemos que um ou três literais nessa cláusula foram invertidos. Suponha que três foram invertidos para uma das cláusulas. Mas então usamos pelo menos o orçamento .$b+1$$n + m + 2$

Suponha que seja uma instância yes com uma atribuição 1 em 3 . Inverta todos os vértices que correspondem a . Como cada cláusula é satisfeita por exatamente uma variável, para cada cláusula existe agora um vértice azul e, para cada variável, exatamente uma delas é azul; portanto, temos vértices azuis.$\phi$$\alpha: V(\phi) \to \{\top,\bot\}$$\alpha$$n + m = b$

Pål GD explica que o problema é difícil para NP, portanto, o próximo passo é tentar encontrar algoritmos razoáveis ​​para o seu problema.

Observarei que seu problema pode ser reduzido para CÓDIGO MÍNIMO DE PESO: dado um código linear, encontre uma palavra de código com peso mínimo. Outra maneira de afirmar esse problema é: dada uma matriz booleana e um vetor booleano , encontre um vetor booleano diferente de zero modo que o peso Hamming de seja minimizado. (Toda aritmética é executada no módulo 2.) O CÓDIGO DE PESO MÍNIMO é conhecido por ser NP-rígido, mas existem alguns algoritmos para ele que são mais rápidos que a força bruta.$M$$y$$x$$Mx \oplus y$

Aqui está a conexão. Se houver vértices, qualquer vetor booleano de bits poderá ser considerado como especificando quais vértices serão invertidos por uma operação de inversão específica. Assim, para cada vértice , obtemos um vetor de flip correspondente . Coloque-os em uma matriz , em que cada linha corresponde a um flip-vetor diferente. Seja um vetor booleano de bits que especifique as cores originais dos vértices (azul = 1, vermelho = 0). Agora, o objetivo é encontrar um vetor booleano que minimize o peso de Hamming de$n$$n$$v$$m_v$$n \times n$$y$$n$$x$$Mv \oplus y$. Qualquer vetor desse tipo corresponde imediatamente a um conjunto de operações inversas que minimiza o número de vértices azuis no gráfico.

Com esse histórico, você pode aplicar algoritmos conhecidos para localizar palavras de código de peso mínimo em códigos lineares para o seu problema. O tempo de execução ainda será exponencial, mas mais rápido do que tentar todas as possibilidades para . $x$