# Longest subsequence with a given OR value : Dynamic Programming Approach

• Last Updated : 13 May, 2021

Given an array arr[], the task is to find the longest subsequence with a given OR value M. If there is no such sub-sequence then print 0.

Examples:

Input: arr[] = {3, 7, 2, 3}, M = 3
Output:
{3, 2, 3} is the required subsequence
3 | 2 | 3 = 3
Input: arr[] = {2, 2}, M = 3
Output: 0

Approach: A simple solution is to generate all the possible sub-sequences and then find the largest among them with the required OR value. However, for smaller values of M, a dynamic programming approach can be used.
Let’s look at the recurrence relation first.

dp[i][curr_or] = max(dp[i + 1][curr_or], dp[i + 1][curr_or | arr[i]] + 1)

Let’s understand the states of DP now. Here, dp[i][curr_or] stores the longest subsequence of the subarray arr[i…N-1] such the curr_or gives M when gets ORed with this subsequence. At each step, either choose the index i and update curr_or or reject index i and continue.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define maxN 20``#define maxM 64` `// To store the states of DP``int` `dp[maxN][maxM];``bool` `v[maxN][maxM];` `// Function to return the required length``int` `findLen(``int``* arr, ``int` `i, ``int` `curr,``            ``int` `n, ``int` `m)``{``    ``// Base case``    ``if` `(i == n) {``        ``if` `(curr == m)``            ``return` `0;``        ``else``            ``return` `-1;``    ``}` `    ``// 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``    ``int` `l = findLen(arr, i + 1, curr, n, m);``    ``int` `r = findLen(arr, i + 1, curr | arr[i], n, m);``    ``dp[i][curr] = l;``    ``if` `(r != -1)``        ``dp[i][curr] = max(dp[i][curr], r + 1);``    ``return` `dp[i][curr];``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 3, 7, 2, 3 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``);``    ``int` `m = 3;` `    ``int` `ans = findLen(arr, 0, 0, n, m);``    ``if` `(ans == -1)``        ``cout << 0;``    ``else``        ``cout << ans;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{` `static` `int` `maxN = ``20``;``static` `int` `maxM = ``64``;` `// To store the states of DP``static` `int` `[][]dp = ``new` `int``[maxN][maxM];``static` `boolean` `[][]v = ``new` `boolean``[maxN][maxM];` `// Function to return the required length``static` `int` `findLen(``int``[] arr, ``int` `i,``                   ``int` `curr, ``int` `n, ``int` `m)``{``    ``// Base case``    ``if` `(i == n)``    ``{``        ``if` `(curr == m)``            ``return` `0``;``        ``else``            ``return` `-``1``;``    ``}` `    ``// 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``    ``int` `l = findLen(arr, i + ``1``, curr, n, m);``    ``int` `r = findLen(arr, i + ``1``, curr | arr[i], n, m);``    ``dp[i][curr] = l;``    ``if` `(r != -``1``)``        ``dp[i][curr] = Math.max(dp[i][curr], r + ``1``);``    ``return` `dp[i][curr];``}` `// Driver code``public` `static` `void` `main(String []args)``{``    ``int` `arr[] = { ``3``, ``7``, ``2``, ``3` `};``    ``int` `n = arr.length;``    ``int` `m = ``3``;` `    ``int` `ans = findLen(arr, ``0``, ``0``, n, m);``    ``if` `(ans == -``1``)``        ``System.out.println(``0``);``    ``else``        ``System.out.println(ans);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of the approach``import` `numpy as np` `maxN ``=` `20``maxM ``=` `64` `# To store the states of DP``dp ``=` `np.zeros((maxN, maxM));``v ``=` `np.zeros((maxN, maxM));` `# Function to return the required length``def` `findLen(arr, i, curr, n, m) :` `    ``# Base case``    ``if` `(i ``=``=` `n) :``        ``if` `(curr ``=``=` `m) :``            ``return` `0``;``        ``else` `:``            ``return` `-``1``;` `    ``# 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``    ``l ``=` `findLen(arr, i ``+` `1``, curr, n, m);``    ``r ``=` `findLen(arr, i ``+` `1``, curr | arr[i], n, m);``    ``dp[i][curr] ``=` `l;``    ``if` `(r !``=` `-``1``) :``        ``dp[i][curr] ``=` `max``(dp[i][curr], r ``+` `1``);``    ``return` `dp[i][curr];` `# Driver code``if` `__name__ ``=``=` `"__main__"` `:` `    ``arr ``=` `[ ``3``, ``7``, ``2``, ``3` `];``    ``n ``=` `len``(arr);``    ``m ``=` `3``;` `    ``ans ``=` `findLen(arr, ``0``, ``0``, n, m);``    ``if` `(ans ``=``=` `-``1``) :``        ``print``(``0``);``    ``else` `:``        ``print``(ans);` `# 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 the states of DP``static` `int` `[,]dp = ``new` `int``[maxN,maxM];``static` `bool` `[,]v = ``new` `bool``[maxN,maxM];` `// Function to return the required length``static` `int` `findLen(``int``[] arr, ``int` `i,``                ``int` `curr, ``int` `n, ``int` `m)``{``    ``// Base case``    ``if` `(i == n)``    ``{``        ``if` `(curr == m)``            ``return` `0;``        ``else``            ``return` `-1;``    ``}` `    ``// 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``    ``int` `l = findLen(arr, i + 1, curr, n, m);``    ``int` `r = findLen(arr, i + 1, curr | arr[i], n, m);``    ``dp[i,curr] = l;``    ``if` `(r != -1)``        ``dp[i,curr] = Math.Max(dp[i,curr], r + 1);``    ``return` `dp[i,curr];``}` `// Driver code``public` `static` `void` `Main(String []args)``{``    ``int` `[]arr = { 3, 7, 2, 3 };``    ``int` `n = arr.Length;``    ``int` `m = 3;` `    ``int` `ans = findLen(arr, 0, 0, n, m);``    ``if` `(ans == -1)``        ``Console.WriteLine(0);``    ``else``        ``Console.WriteLine(ans);``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output:

`3`

Time Complexity: O(N * maxArr) where maxArr is the maximum element from the array.

My Personal Notes arrow_drop_up