Problem:
Score : 300 points

Problem Statement

There are N observatories in AtCoder Hill, called Obs. 1, Obs. 2, ..., Obs. N. The elevation of Obs. i is H_i.
There are also M roads, each connecting two different observatories. Road j connects Obs. A_j and Obs. B_j.

Obs. i is said to be good when its elevation is higher than those of all observatories that can be reached from Obs. i using just one road.
Note that Obs. i is also good when no observatory can be reached from Obs. i using just one road.

How many good observatories are there?

Constraints

2 \leq N \leq 10^5

1 \leq M \leq 10^5

1 \leq H_i \leq 10^9

1 \leq A_i,B_i \leq N

A_i \neq B_i

Multiple roads may connect the same pair of observatories.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M
H_1 H_2 ... H_N
A_1 B_1
A_2 B_2
:
A_M B_M

Output

Print the number of good observatories.

Sample Input 1

4 3
1 2 3 4
1 3
2 3
2 4

Sample Output 1

2

From Obs. 1, you can reach Obs. 3 using just one road. The elevation of Obs. 1 is not higher than that of Obs. 3, so Obs. 1 is not good.

From Obs. 2, you can reach Obs. 3 and 4 using just one road. The elevation of Obs. 2 is not higher than that of Obs. 3, so Obs. 2 is not good.

From Obs. 3, you can reach Obs. 1 and 2 using just one road. The elevation of Obs. 3 is higher than those of Obs. 1 and 2, so Obs. 3 is good.

From Obs. 4, you can reach Obs. 2 using just one road. The elevation of Obs. 4 is higher than that of Obs. 2, so Obs. 4 is good.

Thus, the good observatories are Obs. 3 and 4, so there are two good observatories.

Sample Input 2

6 5
8 6 9 1 2 1
1 3
4 2
4 3
4 6
4 6

Sample Output 2

3

Solution in C# (Mono-csc 3.5.0) (judge verdict: Accepted)

using System;
using static System.Console;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace Atcoder_Answer
{
    class Program
    {
        const Int32 mod = 1000000007;

        static void Main(string[] args)
        {
            string[] Reader = ReadLine().Split(' ');

            int N = int.Parse(Reader[0]);
            int M = int.Parse(Reader[1]);

            Reader = ReadLine().Split(' ');

            List<Tower> Towers = new List<Tower>();

            for (int loop = 0; loop < N; loop++)
            {
                Towers.Add(new Tower(int.Parse(Reader[loop])));
            }

            for (int loop = 0; loop < M; loop++)
            {
                Reader = ReadLine().Split(' ');

                Towers[int.Parse(Reader[0]) - 1].Connection.Add(int.Parse(Reader[1]) - 1);
                Towers[int.Parse(Reader[1]) - 1].Connection.Add(int.Parse(Reader[0]) - 1);
            }


            WriteLine(Judge(Towers));
        }

        #region Functions
        public decimal floor(float d) => Math.Floor((decimal)d);
        #endregion

        class Tower
        {
            public List<int> Connection { get; set; }
            public int Height { get; set; }
            public bool Judged = false;

            public Tower(int Height)
            {
                this.Height = Height;
                this.Connection = new List<int>();
            }

            public Tower(int Height, params int[] Connection)
            {
                this.Height = Height;
                this.Connection = Connection.ToList();
            }
        }

        static int Judge(List<Tower> Towers)
        {
            int Score = 0;

            for (int loop = 0; loop < Towers.Count; loop++) 
            {
                if (Towers[loop].Judged) continue;

                for (int j = 0; j < Towers[loop].Connection.Count; j++)
                {
                    Towers[Towers[loop].Connection[j]].Judged = true;

                    if (Towers[loop].Height <= Towers[Towers[loop].Connection[j]].Height)
                    {
                        Towers[Towers[loop].Connection[j]].Judged = false;

                        goto JudgeEnd;
                    }
                }

                Score++;

            JudgeEnd:; //一つの展望台の確認の終了

                Towers[loop].Judged = true;
            }

            return Score;
        }
    }

    public static class Extension
    {
        #region 拡張:bool
        #region キャスト関連
        public static int ToInt(this bool Bool)
        {
            if (Bool) return 1;
            else return 0;
        }

        public static string ToString(this bool Bool, string TrueStr, string FalseStr)
        {
            if (Bool) return TrueStr;
            else return FalseStr;
        }
        #endregion
        #endregion

        #region 拡張:int
        #region キャスト関連
        public static char ToAlphaBets(this int Base) => (char)Base;
        #endregion
        #endregion

        #region 拡張:char
        #region 変換関連
        public static char NextAlpha(this char Char) => (char)((Char) + 1); //次の文字を取得
        #endregion
        #endregion

        #region 拡張:int[]
        public static long Sum(this int[] Array)
        {
            int Ret = 0;
            for (int loop = 0; loop < Array.Length; loop++) Ret += Array[loop];
            return Ret;
        }
        #endregion

        #region 拡張: string
        public static string Multi(this string THIS, int Value)
        {
            string RetValue = "";

            for (int loop = 0; loop < Value; loop++) RetValue += THIS;

            return RetValue;
        }
        #endregion

        #region 拡張: List<string>
        public static string Sum(this List<string> THIS, string Split)
        {
            string RetValue = "";

            for (int loop = 0; loop < THIS.Count; loop++)
            {
                RetValue += THIS[loop];
            }

            return RetValue;
        }
        #endregion
    }
}