// Problem : C - Peaks
// Contest : AtCoder - AtCoder Beginner Contest 166
// URL : https://atcoder.jp/contests/abc166/tasks/abc166_c
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)

//S->----------------------------------------------------|
//R->--------------</AUTHOR - SRIJAN DE>-----------------|
//I->----</JALPAIGURI GOVERNMENT ENGINEERING COLLEGE>----|
//J->------------</INFORMATION TECHNOLOGY>---------------|
//A->-------------</sd2220@it.jgec.ac.in>----------------|
//N->----------------------------------------------------|

#include    <bits/stdc++.h>
#include    <ext/pb_ds/assoc_container.hpp> // Policy_based_Data_Structure 
#include    <ext/pb_ds/tree_policy.hpp>
using       namespace            std;
using       namespace            __gnu_pbds;

/*#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;*/

using       lli=                 long long ;
using       ull=                 unsigned long long ;
using       ld=                  long double;
#define     int                  long long
#define     mem(a,val)           memset( a,  val,  sizeof(a) )
#define     b_s                  binary_search
#define     u_b                  upper_bound
#define     l_b                  lower_bound
#define     nl                   cout<<endl
#define     pb                   push_back
#define     pf                   push_front
#define     ppb                  pop_back
#define     ppf                  pop_front
#define     in                   insert
#define     fi                   first
#define     se                   second
#define     pqueue               priority_queue
#define     rr                   return
#define     fr0(var,beg,end)     for(int var=beg;var<end;var++)
#define     fr1(var,end,beg)     for(int var=end-1;var>=beg;var--)
typedef tree<int, null_type,less<int>, rb_tree_tag, tree_order_statistics_node_update> indexed_set;

bool isprime(int n);
bool ispalin(int num);
bool isleapyear(int year);
int __lcm(int a, int b); 
int power(int x,int y);
int digitsum(int n);
int lsb(int x);
int fact(int n);
int npr(int n, int r);
int ncr(int n, int r);
int evensum(int n);
int oddsum(int n);
int find_set(int v);
void make_set(int v);
void union_sets(int a, int b);
void print(int arr[], int n);
void sorts(string &str);
const int   N=                   1e6+7;
const int   MOD=                 (int)1e9 + 7;
const int   MOD1=                (int)1e9 + 9;
const int   MOD2=                998244353;
const ld    pi=                  atan2(0, -1);
const ld    eps=                 1e-9;
int         tests=               1;
template<class x,class y>x max(x a,y b){return (a>b)?a:b;}
template<class x,class y>x min(x a,y b){return (a<b)?a:b;}
template<class x,class y>x log(x n,y r){return (n>r-1)?1+log(n/r,r):0;}

class Union_Find {
  public:
    vector<int> rank;
    vector<int> parent;
  public:
    Union_Find(int N) {
      rank.resize(N, 1);
      parent.resize(N, 0);
      iota(parent.begin(), parent.end(), 0);
    }
 

        
    int find_set(int v) {
        if (v == parent[v])
            return v;
        return parent[v] = find_set(parent[v]);
    }
    
    int set_size(int v)
    {
        return rank[v];
    }
    void union_sets(int a, int b) {
        a = find_set(a);
        b = find_set(b);
        if (a != b) {
            if (rank[a] < rank[b])
                swap(a, b);
            parent[b] = a;
            rank[a] += rank[b];
        }
    }
};
vector<int> adj[100001];
int vis[100001]={0};
// int parent[N];
// int sz[N];

///.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.

int32_t main() 
{
	auto start = clock();
	ios_base::sync_with_stdio(0);
	cout.tie(0);
	cin.tie(0);	

//	cout<<fixed;
//	cout<<scientific;
//	cout<<fixed<<setprecision(12);
	// cin>>tests;
	for(int test=1;test<=tests;test++) 
	{
//		cout<<"Case #"<<test<<": ";
///.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.

		
		
			int n,m;
			cin>>n>>m;
			int a[n+1];
			int aa[n+1];
			
			for(int i=1;i<=n;i++)
			{
			    cin>>a[i];
			}
			aa[n]=0;
			while(m--)
			{
			    int x,y;
			    cin>>x>>y;
			    adj[x].pb(a[y]);
			    adj[y].pb(a[x]);
			}
			
			int ans=0;
			for(int i=1;i<=n;i++)
			{
			    int maxi=0;
			    for(auto i:adj[i])
			    {
			        maxi=max(maxi,i);
			    }
			    
			    if(maxi<a[i])
			    ans++;
			    
			}
	    	cout<<ans;
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
///.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.
		
	}
	cerr<<endl<<endl<<endl<< "Time : " << double(clock() - start) / CLOCKS_PER_SEC <<endl;
	return 0;
}







///.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.


























bool isprime(int n)
{
    bool prime[n + 1];
    memset( prime , true, sizeof(prime));
    for (int p = 2; p * p <= n; p++) {
        if (prime[p] == true) {
            for (int i = p * p; i <= n; i += p)
                prime[i] = false;
        }
    }
    if(n==1)
        return false;
    else if (prime[n])
        return true;
    else
        return false;
}
 
bool ispalin(int num)
{
    bool flag=false;
    int digit,rev=0,n=num;
    do
     {
         digit = num % 10;
         rev = (rev * 10) + digit;
         num = num / 10;
     } while (num != 0);
     if(rev==n)
     flag=true;
     return flag;
}

bool isleapyear(int year)  
{  
    if (year % 400 == 0)  
        return true;  
    
    if (year % 100 == 0)  
        return false;  
  
    if (year % 4 == 0)  
        return true;  
    return false;  
}  
int lsb(int x)
{
    return x&(-x);
}

int __lcm(int a, int b)  
{  
return (a*b)/__gcd(a, b);  
}
 
int power(int x,int y) 
{ 
	int temp; 
	if( y == 0) 
		return 1; 
	temp = pow(x, y/2); 
	if (y%2 == 0) 
		return temp*temp; 
	else
		return x*temp*temp; 
}

int digitsum(int n)
{
    int c=0;
    while(n>0)
    {
        c++;
        n/=10;
    }
    return c;
}

int fact(int n) 
{ 
    if (n <= 1) 
        return 1; 
    return n * fact(n - 1); 
}  

int ncr(int n, int r) 
{ 
    long long p = 1, k = 1; 
    if (n - r < r) 
        r = n - r; 
  
    if (r != 0) { 
        while (r) { 
            p *= n; 
            k *= r; 
            int m = __gcd(p, k); 
            p /= m; 
            k /= m; 
            n--; 
            r--; 
        } 
    } 
    else
        p = 1; 
    return p;
} 

int npr(int n, int r) 
{ 
    return fact(n) / fact(n - r); 
} 

int evensum(int n)
{
	return (n/2*(n/2+1));
}

int oddsum(int n)
{
	return (((n+1)/2)*((n+1)/2));
} 

void sorts(string &str)
{
	sort(str.begin(), str.end());
}


Measured memory_bytes: 10376