#pragma comment(linker, "/STACK:512000000")
//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#include <bits/stdc++.h>
#ifdef AIM
#include <sys/resource.h>
#endif
using namespace std;

#define all(a) a.begin(), a.end()
typedef long long li;
typedef long double ld;
void solve(__attribute__((unused)) bool);
void precalc();
clock_t start;
#define FILENAME ""

int main() {
#ifdef AIM
  string s = FILENAME;
//    assert(!s.empty());
  freopen("/home/alexandero/ClionProjects/cryptozoology/input.txt", "r", stdin);
  //freopen("/home/alexandero/ClionProjects/cryptozoology/output.txt", "w", stdout);
#else
//    freopen(FILENAME ".in", "r", stdin);
//    freopen(FILENAME ".out", "w", stdout);
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
#endif
    start = clock();
    int t = 1;
#ifndef AIM
  cout.sync_with_stdio(0);
  cin.tie(0);
#endif

#ifdef AIM
  const rlim_t kStackSize = 256 * 1024 * 1024;
  struct rlimit rl;
  int result;

  result = getrlimit(RLIMIT_STACK, &rl);
  if (result == 0)
  {
    if (rl.rlim_cur < kStackSize)
    {
      rl.rlim_cur = kStackSize;
      result = setrlimit(RLIMIT_STACK, &rl);
      if (result != 0)
      {
        fprintf(stderr, "setrlimit returned result = %d\n", result);
      }
    }
  }
#endif

  precalc();
  cout.precision(10);
  cout << fixed;
  //cin >> t;
  int testNum = 1;
  while (t--) {
      //cout << "Case #" << testNum++ << ": ";
      solve(true);
  }
  cout.flush();
#ifdef AIM1
    while (true) {
      solve(false);
  }
#endif

#ifdef AIM
  cout.flush();
  auto end = clock();

  usleep(10000);
  print_stats(end - start);
  usleep(10000);
#endif

    return 0;
}

template<typename T>
T binpow(T q, T w, T mod) {
    if (!w)
        return 1 % mod;
    if (w & 1)
        return q * 1LL * binpow(q, w - 1, mod) % mod;
    return binpow(q * 1LL * q % mod, w / 2, mod);
}

template<typename T>
T gcd(T q, T w) {
    while (w) {
        q %= w;
        swap(q, w);
    }
    return q;
}
template<typename T>
T lcm(T q, T w) {
    return q / gcd(q, w) * w;
}

template <typename T>
void make_unique(vector<T>& a) {
    sort(all(a));
    a.erase(unique(all(a)), a.end());
}

template<typename T>
void relax_min(T& cur, T val) {
    cur = min(cur, val);
}

template<typename T>
void relax_max(T& cur, T val) {
    cur = max(cur, val);
}

void precalc() {
}

#define int li
const int mod = 1000000007;

struct Dsu {
  vector<int> dsu;
  Dsu(int n) {
    dsu.resize(n);
    iota(all(dsu), 0);
  }
  int find_set(int v) {
    if (dsu[v] == v) {
      return v;
    }
    return dsu[v] = find_set(dsu[v]);
  }
  bool merge(int q, int w) {
    q = find_set(q);
    w = find_set(w);
    if (w == q) {
      return false;
    }
    dsu[w] = q;
    return true;
  }
};

const int C = 5010;

int dp[C][C];

void add(int& cur, int val) {
  cur += val;
  cur %= mod;
}

void solve(__attribute__((unused)) bool read) {
  int n;
  cin >> n;
  Dsu dsu(n);
  vector<char> is_free(n, false);
  int comps = n;
  int n_free = 0;
  for (int i = 0; i < n; ++i) {
    int p;
    cin >> p;
    if (p == -1) {
      is_free[i] = true;
      ++n_free;
    } else {
      --p;
      if (dsu.merge(i, p)) {
        --comps;
      }
    }
  }
  int default_comps = comps - n_free;
  int res = binpow(n - 1, n_free, mod) * (n - default_comps) % mod;

  //cout << default_comps << " " << res << endl;

  vector<char> has_free(n);
  vector<int> sizes(n);
  for (int i = 0; i < n; ++i) {
    int c = dsu.find_set(i);
    ++sizes[c];
    if (is_free[i]) {
      has_free[c] = true;
    }
  }
  {
    vector<int> szs;
    for (int i = 0; i < n; ++i) {
      if (has_free[i]) {
        szs.push_back(sizes[i]);
      }
    }
    sizes.swap(szs);
  }
  for (int s : sizes) {
    add(res, mod - ((s - 1) * binpow(n - 1, n_free - 1, mod)) % mod);
  }

  dp[0][0] = 1;
  for (int i = 0; i < sizes.size(); ++i) {
    //cout << sizes[i] << " ";
    for (int cnt = 0; cnt <= i; ++cnt) {
      add(dp[i + 1][cnt], dp[i][cnt]);
      add(dp[i + 1][cnt + 1], dp[i][cnt] * sizes[i]);
    }
  }
  //cout << endl;
  int fact = 1;
  for (int cnt = 2; cnt <= sizes.size(); ++cnt) {
    //cout << cnt << " " << dp[sizes.size()][cnt] << endl;
    fact = fact * (cnt - 1) % mod;
    add(res, mod - ((dp[sizes.size()][cnt] * fact % mod) * binpow(n - 1, n_free - cnt, mod)) % mod);
  }
  cout << res << "\n";

}

Measured memory_bytes: 120448