Número de subconjuntos con un valor OR dado

Dada una array arr[] de longitud N , la tarea es encontrar el número de subconjuntos con un valor OR dado M.
Ejemplos: 

Entrada: arr[] = {2, 3, 2} M = 3 
Salida:
Todos los subconjuntos posibles y sus valores OR son: 
{2} = 2 
{3} = 3 
{2} = 2 
{2, 3} = 2 | 3 = 3 
{3, 2} = 3 | 2 = 3 
{2, 2} = 2 | 2 = 2 
{2, 3, 2} = 2 | 3 | 2 = 3

Entrada: arr[] = {1, 3, 2, 2}, M = 5 
Salida:

 

Enfoque: Un enfoque simple es resolver el problema generando todos los subconjuntos posibles y luego contando el número de subconjuntos con el valor OR dado. Sin embargo, para valores más pequeños de elementos de array, se puede resolver mediante programación dinámica
Veamos primero la relación de recurrencia. 

dp[i][curr_or] = dp[i + 1][curr_or] + dp[i + 1][curr_or | arr[yo]] 

La relación de recurrencia anterior se puede definir como el número de subconjuntos de subarreglo arr[i…N-1] de tal manera que si se les hace OR con curr_or se obtendrá el valor OR requerido. 
La relación de recurrencia se justifica ya que solo hay caminos. Puede tomar el elemento actual y O con curr_or o ignorarlo y seguir adelante.
A continuación se muestra la implementación del enfoque anterior: 
 

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
#define maxN 20
#define maxM 64
 
// To store states of DP
int dp[maxN][maxM];
bool v[maxN][maxM];
 
// Function to return the required count
int findCnt(int* arr, int i, int curr, int n, int m)
{
    // Base case
    if (i == n) {
        return (curr == m);
    }
 
    // If the state has been solved before
    // return the value of the state
    if (v[i][curr])
        return dp[i][curr];
 
    // Setting the state as solved
    v[i][curr] = 1;
 
    // Recurrence relation
    dp[i][curr]
        = findCnt(arr, i + 1, curr, n, m)
          + findCnt(arr, i + 1, (curr | arr[i]), n, m);
 
    return dp[i][curr];
}
 
// Driver code
int main()
{
    int arr[] = { 2, 3, 2 };
    int n = sizeof(arr) / sizeof(int);
    int m = 3;
 
    cout << findCnt(arr, 0, 0, n, m);
 
    return 0;
}

Java

// Java implementation of the approach
import java.util.*;
class GFG
{
     
static int maxN = 20;
static int maxM = 64;
 
// To store states of DP
static int [][]dp = new int[maxN][maxM];
static boolean [][]v = new boolean[maxN][maxM];
 
// Function to return the required count
static int findCnt(int[] arr, int i,
                   int curr, int n, int m)
{
    // Base case
    if (i == n)
    {
        return (curr == m ? 1 : 0);
    }
 
    // If the state has been solved before
    // return the value of the state
    if (v[i][curr])
        return dp[i][curr];
 
    // Setting the state as solved
    v[i][curr] = true;
 
    // Recurrence relation
    dp[i][curr] = findCnt(arr, i + 1, curr, n, m) +
                  findCnt(arr, i + 1, (curr | arr[i]), n, m);
 
    return dp[i][curr];
}
 
// Driver code
public static void main(String []args)
{
    int arr[] = { 2, 3, 2 };
    int n = arr.length;
    int m = 3;
 
    System.out.println(findCnt(arr, 0, 0, n, m));
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 implementation of the approach
import numpy as np
 
maxN = 20
maxM = 64
 
# To store states of DP
dp = np.zeros((maxN, maxM));
v = np.zeros((maxN, maxM));
 
# Function to return the required count
def findCnt(arr, i, curr, n, m) :
 
    # Base case
    if (i == n) :
        return (curr == m);
 
    # If the state has been solved before
    # return the value of the state
    if (v[i][curr]) :
        return dp[i][curr];
 
    # Setting the state as solved
    v[i][curr] = 1;
 
    # Recurrence relation
    dp[i][curr] = findCnt(arr, i + 1, curr, n, m) + \
                  findCnt(arr, i + 1, (curr | arr[i]), n, m);
 
    return dp[i][curr];
 
# Driver code
if __name__ == "__main__" :
 
    arr = [ 2, 3, 2 ];
    n = len(arr);
    m = 3;
 
    print(findCnt(arr, 0, 0, n, m));
 
# This code is contributed by AnkitRai01

C#

// C# implementation of the approach
using System;
     
class GFG
{
     
static int maxN = 20;
static int maxM = 64;
 
// To store states of DP
static int [,]dp = new int[maxN, maxM];
static Boolean [,]v = new Boolean[maxN, maxM];
 
// Function to return the required count
static int findCnt(int[] arr, int i,
                   int curr, int n, int m)
{
    // Base case
    if (i == n)
    {
        return (curr == m ? 1 : 0);
    }
 
    // If the state has been solved before
    // return the value of the state
    if (v[i, curr])
        return dp[i, curr];
 
    // Setting the state as solved
    v[i, curr] = true;
 
    // Recurrence relation
    dp[i, curr] = findCnt(arr, i + 1, curr, n, m) +
                  findCnt(arr, i + 1, (curr | arr[i]), n, m);
 
    return dp[i, curr];
}
 
// Driver code
public static void Main(String []args)
{
    int []arr = { 2, 3, 2 };
    int n = arr.Length;
    int m = 3;
 
    Console.WriteLine(findCnt(arr, 0, 0, n, m));
}
}
 
// This code is contributed by Rajput-Ji

Javascript

<script>
 
// Javascript implementation of the approach
var maxN = 20
var maxM = 64
 
// To store states of DP
var dp = Array.from(Array(maxN), ()=> Array(maxM));
var v = Array.from(Array(maxN), ()=> Array(maxM));
 
// Function to return the required count
function findCnt(arr, i, curr, n, m)
{
    // Base case
    if (i == n) {
        return (curr == m);
    }
 
    // If the state has been solved before
    // return the value of the state
    if (v[i][curr])
        return dp[i][curr];
 
    // Setting the state as solved
    v[i][curr] = 1;
 
    // Recurrence relation
    dp[i][curr]
        = findCnt(arr, i + 1, curr, n, m)
          + findCnt(arr, i + 1, (curr | arr[i]), n, m);
 
    return dp[i][curr];
}
 
// Driver code
var arr = [2, 3, 2 ];
var n = arr.length;
var m = 3;
document.write( findCnt(arr, 0, 0, n, m));
 
</script>   
Producción

4

Complejidad temporal: O(maxN*maxM), donde maxN y maxM son las constantes definidas.
Espacio Auxiliar: O(maxN*maxM), donde maxN y maxM son las constantes definidas.

Publicación traducida automáticamente

Artículo escrito por DivyanshuShekhar1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *