This is what you are looking for

const int N=20; ll n,m,q,t,u,v,x,y; ll adj[N][N], dp[1<<N][N]; class Execute{ public: int solve(){

cin>>n>>m;
    f(m){
        cin>>u>>v;
        u--,v--;
        adj[u][v]++;
    }
    dp[1][0]=1;
    for(ll i=2;i<(1<<n);i++){
        // if(i==(1<<n)-1)continue;
        // if(i&(1<<(n)))continue;
        if(i!=(1<<n)-1&&((i>>(n-1))&1))continue;
        f2(n){
            if((i&(1<<j))){
                ll ntr=i^(1<<j);
                for(ll k=0;k<n;k++){
                    if((ntr&(1<<k))&&(adj[k][j])){
                        // dp[i][j]+=dp[ntr][k];
                        dp[i][j]+=adj[k][j]*dp[ntr][k];
                        dp[i][j]%=mod;
                    }
                }
            }
        }
    }
    // f((1<<n)){
    //     f2(n){
    //         cout<<dp[i][j]<<" ";
    //     }pn
    // }
    p(dp[(1<<n)-1][n-1])
    return 0;
}

};

You have “ if(state & (1<<curr))” twice.

my approach worked — though i did top down dp

i made one optimisation — if i reach vertex n before rest of the vertices are visited i return 0

maybe topdown works because unlike bottom up all states arent calculated in top down?

i dont really know a lot though i will include my accepted code

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define MOD 1000000007
vector<int>adj[22];
ll dp[1100000][22];
int n;
ll F(int mask, int i)
{
    mask = mask ^ (1 << i);
    if (mask == 0 && i == n - 1)
        return 1;
    if (i == n - 1)
        return 0;
    if (dp[mask][i] != - 1)
        return dp[mask][i];
    dp[mask][i] = 0;
    for (auto j : adj[i])
    {
        if ((mask & (1 << j)))
            dp[mask][i] = (dp[mask][i] + F(mask, j)) % MOD;
    }
    return dp[mask][i];
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int m; cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int a, b; cin >> a >> b; a--; b--;
        adj[a].push_back(b);
    }
    memset(dp, -1, sizeof(dp));
    cout << F((1 << n) - 1, 0);
    return 0;
}