Count Lucky Permutations (IMPORTANT GRAPH PROBLEM)

LINK -> https://practice.geeksforgeeks.org/problems/e9e2da3de3eb35679ca7e17b752ae877635f1a26/1?utm_source=youtube&utm_medium=courseteam_practice_desc&utm_campaign=problem_of_the_day

--------------------------------------------------------------------------------------------------------------------------------------

You are given an array arr[ ] of integers having N elements and a non-weighted undirected graph having N nodes and M edges. The details of each edge in the graph is given to you in the form of list of list.
Your task is to find the number of lucky permutations of the given array.

An array permutation is said to be lucky if for every node Vi  [1 <= i <= N-1] in the array there exists an edge between the nodes Vi and Vi+1 in the given graph.

Example 1:
Input:
N = 3, M = 2
arr = {1, 2, 3}
graph = {{3, 1}, {1, 2}}
Output:
2
Explanation:
All possible permutations of the
array are as follows-
{1,2,3}: There is an edge between 1 and
2 in the graph but not betwen 2 and 3.

{2,1,3}: There is an edge between (2,1)
and (1,3) in the graph.

{3,1,2}: There is an edge between (3,1)
and (1,2) in the graph.

Out of the 3 possible permutations,
2 are lucky. Therefore, answer is 2.


Example 2:
Input:
N = 2, M = 1
arr = {1, 1}
graph = {{1, 2}}
Output :
0
Explanation:
There is no lucky permutation in the
given graph.


Constraints:
2 ≤ N ≤ 15
1 ≤ M ≤ (N*(N-1))/2
1 ≤  arr[i], graph[i][j] ≤ N
There are no self-loops and repeated edges in the graph.



---------------------------------------------------------------------------------------------------------------------------------------


class Solution {
  private:
    vector<vector<bool>> conn;
    long long int dp[17][1<<15];
  public:
    long long int helper(vector<int> &arr, int mask, int prev, int N){
        if(mask==(1 << N)-1){
            return 1;
        }
        if(dp[prev][mask]!=-1){
            return dp[prev][mask];
        }
        long long int res=0;
        for(int i=0;i<N;i++){
            if(mask & (1 << i)){  // if ith bit is visited already, then do not take it
                continue;
            }
            if(prev==16 || conn[arr[prev]][arr[i]]==true){ // if prev OR there is an edge between prev element and current element
                res+=helper(arr,mask | (1 << i),i,N);
            }
        }
        return dp[prev][mask]=res;
    }

    long long int luckyPermutations(int N, int M, vector<int> arr, vector<vector<int>> graph) {
        conn.resize(N+1,vector<bool>(N+1,false));
        memset(dp,-1,sizeof(dp));
        for(auto g: graph){
            conn[g[0]][g[1]]=true;
            conn[g[1]][g[0]]=true;
        }
        return helper(arr,0,16,N);
        /* You can use prev=-1 but you need to check if prev!=-1
           everytime before accessing from dp. better use 16 instead */
    }
};


uses Bitmask to keep track of indexes since indexes are in range 0 to 15 at max, so we can use bitmasking to keep track of index, keep prev index to see what element you are having prev and if it has connection with current one