#include<bits/stdc++.h>
using namespace std;
 
#define MOD 1000000007
template<typename ty1,typename ty2>
inline int add(ty1 x, ty2 y) {
	if(y>=MOD)y%=MOD;
	if(x>=MOD)x%=MOD;
    x += y; return x < MOD ? x : x - MOD;
}
template<typename ty1,typename ty2>
inline void addto(ty1 &x, ty2 y) {
		  if(y>=MOD)y%=MOD;
		  if(x>=MOD)x%=MOD;
	      x += y; if (x >= MOD) x -= MOD;
}
template<typename ty1,typename ty2>
inline int sub(ty1 x, ty2 y) {
		if(y>=MOD)y%=MOD;
		 if(x>=MOD)x%=MOD;
        x -= y; return x < 0 ? x + MOD : x;
}
template<typename ty1,typename ty2>
inline void subto(ty1 &x, ty2 y) {
	if(y>=MOD)y%=MOD;
	if(x>=MOD)x%=MOD;
    x -= y; if (x < 0) x += MOD;
}
template<typename ty1,typename ty2>
inline int mul(ty1 x, ty2 y) {
        if(y>=MOD)y%=MOD;
		if(x>=MOD)x%=MOD;
        return 1ll * x * y % MOD;
}
template<typename ty1,typename ty2>
void multo(ty1 &x, ty2 y) {
        if(y>=MOD)y%=MOD;
		if(x>=MOD)x%=MOD;
        x=1ll * x * y % MOD;
}
 
 
long long int ppow(long long int i, long long int j){
		long long int res = 1LL;
		while (j){
			if ((j & 1LL)){
				res *= i;
				if (res >= MOD){
					res %= MOD;
				}
			}
			j >>= 1;
			i *= i;
			if (i >= MOD){
				i %= MOD;
			}
		}
		return res;
	}
class Combination{
	
public:
	vector<long long int> k;
	vector<long long int> r;
	void resize(int N){
		k.resize(N + 2);
		r.resize(N + 2);
		k[0] = 1;
		for (int i = 1; i < N+2; i++){
			k[i] = k[i - 1];
			k[i] *= i;
			if (k[i] >= MOD)k[i] %= MOD;
		}
		long long int al = k[k.size() - 1];
		long long int iv = ppow(k[k.size() - 1],MOD-2);
		r[k.size() - 1] = iv;
		for (int i = (int)(r.size()) - 2; i >= 0; i--){
			r[i] = r[i + 1] * (i + 1);
			if (r[i] >= MOD){
				r[i] %= MOD;
			}
		}
	}
	long long int C(int a, int b){
		if (a < b)return 0;
		long long int up = k[a];
		long long int dw = r[b] * r[a - b];
		dw %= MOD;
		up *= dw;
		up %= MOD;
		return up;
	}
	long long int H(int a, int b){
		return C(a + b - 1, b);
	}
	long long int catalan_number(int n){
		return (C(2 * n, n) + MOD - C(2 * n, n - 1)) % MOD;
	}
};
Combination C;
 
 
int n;
 
vector<int> v;
 
struct UF{
	vector<int> belong;
	vector<int> size;
	vector<int> ed;
	vector<int> indeg;
	vector<int> outdeg;
	void resize(int n){
		belong.assign(n + 1, -1);
		size.assign(n + 1, 1);
		ed.assign(n+1,0);
		indeg.assign(n+1,0);
		outdeg.assign(n+1,0);
	}
	inline int root(int b){
		if (belong[b] == -1){
			return b;
		}
		belong[b] = root(belong[b]);
		return belong[b];
	}
	void merge(int a, int b){
		a = root(a);
		b = root(b);
		if (a == b)return;
		belong[a] = b;
		size[b] += size[a];
		ed[b]+=ed[a];
	}
};
UF uf;
 
#define MAX 5002
int dp[MAX][MAX];


 
int main(){
	cin>>n;
	uf.resize(n+2);
	C.resize(5002);
	long long int overall=1;
	int undecided=0;
	for(int i=0;i<n;i++){
		int p;
		scanf("%d",&p);
		if(p==-1){
			v.push_back(p);
			multo(overall,n-1);
			undecided++;
		}
		else{
			p--;
			v.push_back(p);
			if(uf.root(i)!=uf.root(p)){
				uf.merge(i,p);
			}
		}
	}
	for(int i=0;i<n;i++){
		if(v[i]!=-1){
			uf.ed[uf.root(i)]++;
		}
		if(v[i]==-1){
			uf.outdeg[uf.root(i)]++;
		}
		uf.indeg[uf.root(i)]++;
	}
	long long int cn1=0;
	long long int ans=0;
	vector<pair<int,int> > vv;
	for(int i=0;i<n;i++){
		if(uf.root(i)==i){
			if(v[i]!=-1&&uf.ed[i]==uf.size[i]){
				addto(ans,ppow(n-1,undecided));
			}
			else{
				cn1++;
				vv.push_back(make_pair(uf.indeg[i],uf.outdeg[i]));
			}
		}
	}
	dp[0][0]=1;
	for(int i=0;i<vv.size();i++){
		for(int j=0;j<=i;j++){
			//select
			addto(dp[i+1][j+1],mul(dp[i][j],mul(vv[i].first,vv[i].second)));
			//unselect
			addto(dp[i+1][j],mul(dp[i][j],ppow(n-1,vv[i].second)));
		}
	}
	long long int k=1;
	for(int j=0;j<=n;j++){
		if(j<=1)continue;
		if(dp[vv.size()][j]){
			addto(ans,mul(dp[vv.size()][j],k));
		}
		multo(k,max(j,1));
	}
	//self
	for(int i=0;i<vv.size();i++){
		addto(ans,mul(vv[i].first-1,ppow(n-1,undecided-vv[i].second)));
	}
	multo(overall,n);
	subto(overall,ans);
	printf("%lld\n",overall);
	return 0;
}


Measured memory_bytes: 70880