# 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
Recommended Articles
Page :