#include<bits/stdc++.h>
using namespace std;

#define rep(i, n) for(int (i) = 0; (i) < (n); (i)++)
#define repp(i, n, m) for(int (i) = (n); (i) < (m); (i)++)
#define repn(i, n) for(int (i) = 1; (i) <= (n); (i)++)
#define repr(i, n) for(int (i) = (n-1); (i) >= 0; (i)--)
#define all(x) (x).begin(), (x).end()
#define lint long long
#define ulint unsigned long long
#define ldou long double
#define fi first
#define se second
#define setpre(x) std::cout << fixed << setprecision(x)
#define ii(x) int x; cin >> (x)
#define ii2(x, y) int x, y; cin >> (x) >> (y)
#define ii3(x, y, z) int x, y, z; cin >> (x) >> (y) >> (z)
#define out(x) cout << (x) << endl
#define outs(x) cout << (x) << " "
#define yn(x) cout << ((x)?("Yes"):("No")) << endl
#define YN(x) cout << ((x)?("YES"):("NO")) << endl
#define bit_c(x) __builtin_popcountll(x)

inline void logger(){ std::cout << " [LOGGER] " << endl; }
template<typename A, typename... B>
void logger(const A& a, const B&... b){
    cout << a << " , "; logger(b...);
}

typedef pair<lint, lint> P;
const lint MOD = 1000000007;
const lint MOD9 = 998244353;
const lint INF = MOD * MOD;
const int MAX = 5005;

/* ...o(^-^)o... */

const lint mod = MOD;
class mint{
    public:
        long long x;

    constexpr mint(long long _x = 0) : x((_x%mod+mod)%mod) {}
    constexpr mint operator-() const{
        return mint(-x);
    }
    constexpr mint& operator+=(const mint& a){
        if((x += a.x) >= mod) x -= mod;
        return *this;
    }
    constexpr mint& operator-=(const mint& a){
        if((x += mod-a.x) >= mod) x -= mod;
        return *this;
    }
    constexpr mint& operator*=(const mint& a){
        (x *= a.x) %= mod;
        return *this;
    }
    constexpr mint operator+(const mint& a) const{
        mint res(*this);
        return res+=a;
    }
    constexpr mint operator-(const mint& a) const{
        mint res(*this);
        return res-=a;
    }
    constexpr mint operator*(const mint& a) const{
        mint res(*this);
        return res*=a;
    }
    constexpr mint pow(long long x) const{
        if(!x) return 1;
        mint a = pow(x>>1);
        a *= a;
        if(x&1) a *= *this;
        return a; 
    }
    constexpr mint inv() const{
        return pow(mod-2);
    }
    constexpr mint& operator/=(const mint& a){
        return (*this) *= a.inv();
    }
    constexpr mint operator/(const mint& a) const{
        mint res(*this);
        return res/=a;
    }
    friend istream& operator>>(istream& is, mint& m){
        long long x; is >> x; m = x;
        return is;
    }
    friend ostream& operator<<(ostream& os, const mint& m){
        os << m.x; return os;
    }
};

mint fac[MAX], facinv[MAX], inv[MAX];
void minit(){
    fac[0] = fac[1] = 1;
    facinv[0] = facinv[1] = 1;
    inv[1] = 1;
    for (int i = 2; i < MAX; i++){
        fac[i] = fac[i - 1] * i;
        inv[i] = -mint(mod / i)*inv[mod % i];
        facinv[i] = facinv[i - 1] * inv[i];
    }   
}

mint mcomb(lint a, lint b){
    if (a < b) return 0;
    if (a < 0 || b < 0) return 0;
    return fac[a] * facinv[b] * facinv[a - b];
}
mint mperm(lint a, lint b){
    if (a < b) return 0;
    if (a < 0 || b < 0) return 0;
    return fac[a] * facinv[a - b];
}

// 素集合データ構造 (Union-Find)
struct union_find{
    vector<int> par;
    vector<int> rank;
    vector<int> size;
    vector<bool> flag;
    union_find(int n) : par(n), rank(n), size(n), flag(n){
        for(int i = 0; i < n; i++){
            par[i] = i; rank[i] = 0; size[i] = 1;
        }
    }
    int root(int x){
        if(par[x] == x) return x;
        par[x] = root(par[x]);
        flag[par[x]] = flag[par[x]] | flag[x];
        return par[x];
    }
    void unite(int x, int y){
        int rx = root(x);
        int ry = root(y);
        if (rx == ry) return;
        if (rank[rx] < rank[ry]){
            par[rx] = ry;
            size[ry] += size[rx];
            flag[ry] = flag[ry] | flag[rx];
        }
        else{
            par[ry] = rx;
            if (rank[rx] == rank[ry]) rank[rx]++;
            size[rx] += size[ry];
            flag[rx] = flag[rx] | flag[ry];
        }
    }
    bool same(int x, int y){
        int rx = root(x);
        int ry = root(y);
        return rx == ry;
    }
};

vector<int> to[MAX];
mint dp[MAX][MAX];

int main(){
    minit();

    int n; cin >> n;
    union_find uf(n);
    rep(i, n){
        int a; cin >> a; a--;
        if(a<0){
            uf.flag[uf.root(i)] = true;
            continue;
        }
        uf.unite(a,i);
    }

    vector<bool> seen(n);
    vector<mint> c; mint l = 0;
    rep(i, n){
        int r = uf.root(i);
        if(seen[r]) continue;
        seen[r] = true;
        if(uf.flag[r]){
            c.push_back(uf.size[r]);
        }
        else l += 1;
    }

    int m = c.size();
    if(m == 0){
        out(mint(n)-l); return 0;
    }

    dp[0][1] = c[0];
    rep(i, m) rep(j, m+1){
        if(j == 0){
            dp[i][j] = 1;
            continue;
        }
        if(i == 0){
            if(j == 1) dp[i][j] = c[0];
            continue;
        }
        dp[i][j] = dp[i-1][j] + dp[i-1][j-1] * c[i];
    }
    dp[m-1][1] -= m;

    mint res = 0;
    repn(j, m){
        res += dp[m-1][j] * fac[j-1] * mint(n-1).pow(m-j);
    }
    res += l * mint(n-1).pow(m);
    res = mint(n-1).pow(m)*n - res;
    out(res);
}

Measured memory_bytes: 199300