Cuente las permutaciones cuyo prefijo y sufijo AND sean iguales para cada índice

Dada una matriz arr() de tamaño norteDevuelve el número de permutaciones de la matriz arr() que satisfacen la condición matriz (1) y matriz (2) y . . . & matriz(i) = matriz(i+1) & matriz(i+2) & . . . & llegada(N) para todos i.

Nota: Aquí & denota la operación AND bit a bit.

Ejemplos:

Aporte: norte = 3, dirección () = { 1, 1, 1 }
Producción: 6
Explicación: Dado que todos los números son iguales, cualquiera que sea la permutación que tomemos, la secuencia seguirá la condición anterior. Hay un complete de 6 permutaciones posibles con números de índice del 1 al 3: (1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3 , 1, 2), (3, 2, 1).

Aporte: norte = 4, dirección () = { 1, 3, 5, 1 }
Producción: 4

Acercarse: Este problema se puede resolver a partir de la siguiente concept:

Considere una secuencia arbitraria b1, b2, . . ., mil millones. Primero, definamos las matrices AND_pref y AND_suf de longitud N donde

• AND_prefi = b₁ & b₂ & . . . & b_i y
• AND_sufi = b_i & b_yo+1 & . . . & b_norte.

Según la definición de la sucesión: AND_pref1 = AND_suf2. Ahora AND_pref2 ≤ AND_pref1 = AND_suf2 ≤ AND_suf3. También según la definición, AND_pref2 = AND_suf3. Esto significa que b1 = AND_pref2 = AND_suf3.

De manera related, para todos los i de 1 a n, obtenemos AND_prefi = b1 y AND_sufi = b1.
Por lo tanto para la sucesión, b₁ = segundo_norte y la b_i debe ser una tremendous mascara de b₁ por todo lo que tengo 2 a norte – 1.

Siga los pasos a continuación para resolver el problema:

• Inicializar una variable preY con ( 1 << 30 ) – 1.
• Ejecute un ciclo de i = 0 a n-1 y actualice preY con (preY & arr(i)).
• Inicializar una variable de conteo (digamos centavo) con 0.
• Ejecutar un ciclo desde i = 0 hasta n – 1
  • Si preY = arr(i)luego Incremente cnt en 1.
  • Calcular (cnt * ( cnt – 1 ) * (n – 2) !) % (1e9 + 7) y almacenarlo en la variable de respuesta.
• Devuelve la respuesta.

A continuación se muestra la implementación del enfoque anterior:

// C++ code to implement the above method

#embody <bits/stdc++.h>
utilizing namespace std;
#outline ll lengthy lengthy

// Given mod quantity .
ll mod = 1e9 + 7;

// Operate performing calculation
int countAndGood(int n, vector<int>& arr)
{
    // Initializing preAnd .
    int preAnd = (1 << 30) - 1;

    // Precomputing the And of the array arr
    for (int i = 0; i < n; i++) {
        preAnd = (preAnd & arr(i));
    }

    // Initializing cnt with 0
    ll cnt = 0;

    // Counting the overall quantity in arr which
    // are equal to preAnd
    for (int i = 0; i < n; i++) {
        if (preAnd == arr(i))
            cnt++;
    }

    // Discovering (cnt)P(cnt-2)
    ll ans = (cnt * (cnt - 1)) % mod;

    // Discovering (n-2)!
    ll temp = 1;
    for (ll i = 2; i <= n - 2; i++) {
        temp = (temp * i) % mod;
    }

    // Multiplying temp and ans
    ans = (ans * temp) % mod;

    // Returning ans variable
    return ans;
}

// Driver code
int predominant()
{
    int N = 4;
    vector<int> arr = { 1, 3, 5, 1 };

    // Operate name
    cout << countAndGood(N, arr);

    return 0;
}

Complejidad del tiempo: EN)
Espacio Auxiliar: O(1)

Artículos relacionados: