The Tower is Going Home

 CodeForces - 1044A 

On a chessboard with a width of 109109 and a height of 109109, the rows are numbered from bottom to top from 11 to 109109, and the columns are numbered from left to right from 11to 109109. Therefore, for each cell of the chessboard you can assign the coordinates (x,y)(x,y), where xx is the column number and yy is the row number.

Every day there are fights between black and white pieces on this board. Today, the black ones won, but at what price? Only the rook survived, and it was driven into the lower left corner — a cell with coordinates (1,1)(1,1). But it is still happy, because the victory has been won and it's time to celebrate it! In order to do this, the rook needs to go home, namely — on the upper side of the field (that is, in any cell that is in the row with number 109109).

Everything would have been fine, but the treacherous white figures put spells on some places of the field before the end of the game. There are two types of spells:

• Vertical. Each of these is defined by one number xx. Such spells create an infinite blocking line between the columns xx and x+1x+1.
• Horizontal. Each of these is defined by three numbers x1x1, x2x2, yy. Such spells create a blocking segment that passes through the top side of the cells, which are in the row yy and in columns from x1x1 to x2x2 inclusive. The peculiarity of these spells is that it is impossible for a certain pair of such spells to have a common point. Note that horizontal spells can have common points with vertical spells.

An example of a chessboard.

Let's recall that the rook is a chess piece that in one move can move to any point that is in the same row or column with its initial position. In our task, the rook can move from the cell (r0,c0)(r0,c0) into the cell (r1,c1)(r1,c1) only under the condition that r1=r0r1=r0 or c1=c0c1=c0 and there is no blocking lines or blocking segments between these cells (For better understanding, look at the samples).

Fortunately, the rook can remove spells, but for this it has to put tremendous efforts, therefore, it wants to remove the minimum possible number of spells in such way, that after this it can return home. Find this number!

Input

The first line contains two integers nn and mm (0≤n,m≤1050≤n,m≤105) — the number of vertical and horizontal spells.

Each of the following nn lines contains one integer xx (1≤x<1091≤x<109) — the description of the vertical spell. It will create a blocking line between the columns of xx and x+1x+1.

Each of the following mm lines contains three integers x1x1, x2x2 and yy (1≤x1≤x2≤1091≤x1≤x2≤109, 1≤y<1091≤y<109) — the numbers that describe the horizontal spell. It will create a blocking segment that passes through the top sides of the cells that are in the row with the number yy, in columns from x1x1 to x2x2 inclusive.

It is guaranteed that all spells are different, as well as the fact that for each pair of horizontal spells it is true that the segments that describe them do not have common points.

Output

In a single line print one integer — the minimum number of spells the rook needs to remove so it can get from the cell (1,1)(1,1) to at least one cell in the row with the number 109109

Examples

Input

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

Output

1

Input

1 3
4
1 5 3
1 9 4
4 6 6

Output

1

Input

0 2
1 1000000000 4
1 1000000000 2

Output

2

Input

0 0

Output

0

Input

2 3
4
6
1 4 3
1 5 2
1 6 5

Output

2

Note

In the first sample, in order for the rook return home, it is enough to remove the second horizontal spell.

Illustration for the first sample. On the left it shows how the field looked at the beginning. On the right it shows how the field looked after the deletion of the second horizontal spell. It also shows the path, on which the rook would be going home.

In the second sample, in order for the rook to return home, it is enough to remove the only vertical spell. If we tried to remove just one of the horizontal spells, it would not allow the rook to get home, because it would be blocked from above by one of the remaining horizontal spells (either first one or second one), and to the right it would be blocked by a vertical spell.

Illustration for the second sample. On the left it shows how the field looked at the beginning. On the right it shows how it looked after the deletion of the vertical spell. It also shows the path, on which the rook would be going home.

In the third sample, we have two horizontal spells that go through the whole field. These spells can not be bypassed, so we need to remove both of them.

 Illustration for the third sample. On the left it shows how the field looked at the beginning. On the right it shows how the field looked after the deletion of the horizontal spells. It also shows the path, on which the rook would be going home.

In the fourth sample, we have no spells, which means that we do not need to remove anything.

In the fifth example, we can remove the first vertical and third horizontal spells.

Illustration for the fifth sample. On the left it shows how the field looked at the beginning. On the right it shows how it looked after the deletions. It also shows the path, on which the rook would be going home.

題目大意：第一行輸入兩個整數n,m，代表有n個豎著的牆，其下n行代表豎著的魔法牆的位置，m代表有m個橫著的魔法牆，n行行的m行每行有三個數x1,x2,y，代表在（x1,y）到 (x2,y）之間有一道橫著的魔法牆，問從（1,1）出發到達（x,1e9）至少要消除多少道魔法牆。

解決方法：若要消除魔法牆，則證明當前其處於一個封閉房間內，從（1,1）出發，就證明我們需要找到有多少個不共邊的封閉矩形，因此對於橫著的魔法牆，我們僅需要考慮從1出發的，將其終點存入一個數組a[]中，將豎著的魔法牆的位置存入陣列b[]中，將兩個陣列從大到小排序，以陣列a為基礎遍歷，在陣列b中找到第一個小於它的值（即這兩條邊相交），兩陣列繼續向下遍歷，找到有多少相交的矩形，此題還需考慮一特殊情況即若橫著的魔法牆為（1,1000000000）,則其必須消去，因此在輸入時及時統計這種情況的數量，若數量會大於矩形的個數，則輸出數量，否則直接輸出遍歷得到的答案。

AC程式碼：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <map>
#include <stack>
#include <queue>
#include <vector>
#include <bitset>
#include <set>
#include <utility>
#include <sstream>
#include <iomanip>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(int i=a;i<=b;i++)
const int len=1e6+7;
const int MOD= 1e9;
int a[len];
int b[len];
int main()
{
   int n,m;
   scanf("%d%d",&n,&m);
   rep(i,1,n) scanf("%d",&a[i]);
   sort(a+1,a+n+1,greater<int> ());
   int m1=0;
   int cnt=0;
   rep(i,1,m)
   {
       int x1,x2,y;
       scanf("%d%d%d",&x1,&x2,&y);
       if(x1>1) continue;
       b[++m1]=x2;
       if(x2==1e9) cnt++;
   }
   if(n==0) { n=m1;
    rep(i,1,n) a[i]=1e9;
   }
    sort(b+1,b+1+m1,greater<int> ());
   int ans=0;
   int j=1,i=1;
   for(;i<=n&&j<=m1;){
       if(b[j]<a[i]){
        i++;
       }
       else if(b[j]>=a[i]){
        ans++;j++;i++;
       }
   }
   printf("%d\n",max(ans,cnt));
 return 0;
}