#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset>		//UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip>		//do setprecision
#include <ctime>
#include <complex>
#include <chrono>
#include<unordered_map>
using namespace std;

#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)
#define ALL(u) (u).begin(),(u).end()

#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double

typedef pair<int, int> PII;

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

const int MR = 5010;
const int MOD = 1e9 + 7;

int p[MR], r[MR];

void makeset(int x)
{
	p[x] = x;
	r[x] = 1;
}
void unionset(int x, int y)
{
	if (r[x] < r[y])
		p[y] = x;
	else
		p[x] = y;
}//union set
int findset(int x)
{
	if (p[x] != x)
		p[x] = findset(p[x]);
	return p[x];
}//find set

#define ll long long

ll modPow(ll a, ll x, ll p) {
	// return a^x mod p
	ll res = 1;
	while (x > 0) {
		if (x & 1) res = (res*a) % p;
		a = (a*a) % p;
		x >>= 1;
	}

	return res;
}

bool bad[MR];

int dp[MR][MR];

int main()
{
    int N;
    scanf("%d", &N);
    REP(i, N)
        makeset(i);

    // ile jest skladowych, ktore maja cykl
    int ileC = 0;
    int K = 0;
    REP(i, N)
    {
        int P;
        scanf("%d", &P);
        if (P != -1)
        {
            P--;
            if (findset(i) != findset(P))
                // nowa krawedz
                unionset(findset(i), findset(P));
            else
                // cykl
                ileC++;
        }
        else
        {
            // mamy korzen drzewa
            bad[i] = 1;
            K++;
        }
    }

    int res = N * modPow(N - 1, K, MOD) % MOD;
    // dla kazdego cyklu odejmij po 1 krawedzi dla kazdego przypisania
    res = (res - ileC * modPow(N - 1, K, MOD) % MOD + MOD) % MOD;

    // wylicz rozmiary skladowych
    map<int, int> M;
    REP(i, N)
        M[findset(i)]++;

    // wyznacz rozmiary drzew, ktore maja w korzeniu -1
    vector<int> A;
    REP(i, N)
        if (bad[i])
            A.push_back(M[findset(i)]);

    // rozpatrz osobny przypadek, gdy wybieramy kazdy cykl osobno - nie laczymy ich ze soba
    // policz na ile sposobow mozemy utworzyc cykl dla kazdego drzewa
    // na koniec wymnoz razy liczbe wszystkich pozostalych przypisan - one nie wplywaja na liczbe mozliwych cykli dla danego drzewa
    int sum1 = 0;
    for (int a : A)
        sum1 = (sum1 + a - 1) % MOD;
    res = (res - sum1 * modPow(N - 1, K - 1, MOD) % MOD + MOD) % MOD;

    // dla kazdego cyklu chcemy wyznaczyc liczbe przypisan i mamy wyznaczone wzory
    // teraz licz dp[i][j] - na ile sposobow mozesz wybrac cykl skladajacy sie z j drzew, sposrod pierwszych i drzew, dla kazdego podzbioru j-elementowego
    // wyliczamy to dla cykli skladajacych sie z min 2 skladowych wiec dzialaja normalne wzory
    dp[0][0] = 1;
    FORQ(i, 1, K)
    {
        dp[i][0] = 1;
        FORQ(j, 1, i)
            // wez wszystkie cykle z j drzew sposrod i-1 lub dodaj j-ty cykl do cykli z j-1 drzew
            // mozesz to podlaczyc do kazdego wierzcholka z j-tego drzewa i na 1 sposob to wyjdzie przez korzen
            // dodatkowo to drzewo mozesz wstawic na j-1 pozycji w cyklu lub na 1 jesli zaczynamy go tworzyc dla j == 1
            dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1] * (LL)A[i - 1] % MOD * (j - 1 ? j - 1 : 1)) % MOD;
    }

    int sum = 0;
    FORQ(i, 2, K)
        sum = (sum + dp[K][i] * modPow(N - 1, K - i, MOD)) % MOD;

    printf("%d\n", (res - sum + MOD) % MOD);

    return 0;
}

// FOR GNU C++ use the following pattern:
// Uncomment the code below and change your main into main2
// It does not build in MS C++
// But it does increase the stack size from 256 MB on CF and uses GNU C++

//#include <Processthreadsapi.h>
//#include <iostream>
//#include <Synchapi.h>
//#include <windows.h>
//#include <process.h>
//
//DWORD WINAPI MyThreadFunction(LPVOID lpParam) {
//    main2(nullptr);
//    return 0;
//}
//int main() {
//    auto h = CreateThread(nullptr, 1024 << 20, MyThreadFunction, nullptr, STACK_SIZE_PARAM_IS_A_RESERVATION, nullptr);
//    WaitForSingleObject(h, INFINITE);
//}

Measured memory_bytes: 70344