#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
 
#include <bits/stdc++.h>
 
using namespace std;
 
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
 
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
 
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
 
#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
 
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define ins insert
 
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
 
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 5001; //check the limits, dummy
 
struct mi {
	ll v; explicit operator ll() const { return v; }
	mi() { v = 0; }
	mi(ll _v) { 
		v = (-MOD < _v && _v < MOD) ? _v : _v % MOD;
		if (v < 0) v += MOD;
	}
	friend bool operator==(const mi& a, const mi& b) { 
		return a.v == b.v; }
	friend bool operator!=(const mi& a, const mi& b) { 
		return !(a == b); }
	friend bool operator<(const mi& a, const mi& b) { 
		return a.v < b.v; }
   
	mi& operator+=(const mi& m) { 
		if ((v += m.v) >= MOD) v -= MOD; 
		return *this; }
	mi& operator-=(const mi& m) { 
		if ((v -= m.v) < 0) v += MOD; 
		return *this; }
	mi& operator*=(const mi& m) { 
		v = v*m.v%MOD; return *this; }
	mi& operator/=(const mi& m) { return (*this) *= inv(m); }
	friend mi pow(mi a, ll p) {
		mi ans = 1; assert(p >= 0);
		for (; p; p /= 2, a *= a) if (p&1) ans *= a;
		return ans;
	}
	friend mi inv(const mi& a) { assert(a.v != 0); 
		return pow(a,MOD-2); }
		
	mi operator-() const { return mi(-v); }
	mi& operator++() { return *this += 1; }
	mi& operator--() { return *this -= 1; }
	friend mi operator+(mi a, const mi& b) { return a += b; }
	friend mi operator-(mi a, const mi& b) { return a -= b; }
	friend mi operator*(mi a, const mi& b) { return a *= b; }
	friend mi operator/(mi a, const mi& b) { return a /= b; }
    friend ostream& operator<<(ostream& os, const mi& m) {
        os << m.v; return os;
    }
    friend istream& operator>>(istream& is, mi& m) {
        ll x; is >> x;
        m.v = x;
        return is;
    }
};


typedef vector<mi> vmi;
typedef pair<mi,mi> pmi;
typedef vector<pmi> vpmi;


template<int SZ> struct DSU {
    int parent[SZ], size[SZ], cnt[SZ];

    DSU() {
        F0R(i, SZ) parent[i] = i, size[i] = 0, cnt[i] = 1;
    }

    int get(int x) {
        if (parent[x] != x) parent[x] = get(parent[x]);
        return parent[x];
    }

    void unify(int x, int y) {
        x = get(x); y = get(y);
        if (x == y) return;
        if (size[x] < size[y]) swap(x, y);
        cnt[x] += cnt[y];
        if (size[x] == size[y]) size[x]++;
        parent[y] = x;

    }
};

int main() {
	ios_base::sync_with_stdio(0); cin.tie(0);    
	
    int N; cin >> N;
    int A[N]; 
    F0R(i, N) {
        cin >> A[i]; A[i]--;
    }

    F0R(i, N) {
        if (A[i] < 0) A[i]++;
    }

    DSU<MX> dsu;
    F0R(i, N) {
        if (A[i] >= 0) {
            dsu.unify(i, A[i]);
        }
    }

    mi ans = 0;
    F0R(i, N) {
        if (dsu.get(i) == i) ans+=1;
    }
    ll K = 0; F0R(i, N) if (A[i] == -1) K++;

    mi total = N-1;
    total = pow(total, K);

    /*ans *= total;
    F0R(i, N) {
        if (A[i] == -1) {
            mi cur = dsu.cnt[dsu.get(i)];
            mi val = total;
            val -= (cur - 1) * pow(N - 1 - cur, K - 1);
            ans -= val;
            cout << ans << nl;
        }
    }*/

    mi prods[K+1]; F0R(i, K+1) prods[i] = 0;
    prods[0] = 1;
    F0R(i, N) {
        if (A[i] != -1) continue;
        F0Rd(j, K) {
            prods[j+1] += prods[j] * dsu.cnt[dsu.get(i)];
        }
    }

    mi fac = 1;
    mi cycs = 0;
    FOR(i, 1, K+1) {
        cycs *= N-1;
        cycs += fac * prods[i];
        if (i == 1) cycs -= K;
        fac *= i;
    }

    cycs += (ans-K) * total;

    cout << total*N-cycs << nl;
	
	return 0;
}
 
// read the question correctly (ll vs int)
// template by bqi343



Measured memory_bytes: 3800