์ธ์ ๋ ์ต๊ณ ๋ง์ ์งํฅํ๋ ๊ตด์ง์ ๋๊ธฐ์ ์ง์ ์ฃผ์ํ์ฌ๊ฐ ์ ๊ท ์ฌ์ ์ฑ์ฉ์ ์ค์ํ๋ค. ์ธ์ฌ ์ ๋ฐ ์ํ์ 1์ฐจ ์๋ฅ์ฌ์ฌ์ 2์ฐจ ๋ฉด์ ์ํ์ผ๋ก ์ด๋ฃจ์ด์ง๋ค. ์ต๊ณ ๋ง์ ์งํฅํ๋ค๋ ๊ธฐ์ ์ ์ด๋ ์ ๋ฐ๋ผ ๊ทธ๋ค์ ์ต๊ณ ์ ์ธ์ฌ๋ค๋ง์ ์ฌ์์ผ๋ก ์ ๋ฐํ๊ณ ์ถ์ด ํ๋ค.
๊ทธ๋์ ์ง์ ์ฃผ์ํ์ฌ๋, ๋ค๋ฅธ ๋ชจ๋ ์ง์์์ ๋น๊ตํ์ ๋ ์๋ฅ์ฌ์ฌ ์ฑ์ ๊ณผ ๋ฉด์ ์ํ ์ฑ์ ์ค ์ ์ด๋ ํ๋๊ฐ ๋ค๋ฅธ ์ง์์๋ณด๋ค ๋จ์ด์ง์ง ์๋ ์๋ง ์ ๋ฐํ๋ค๋ ์์น์ ์ธ์ ๋ค. ์ฆ, ์ด๋ค ์ง์์ A์ ์ฑ์ ์ด ๋ค๋ฅธ ์ด๋ค ์ง์์ B์ ์ฑ์ ์ ๋นํด ์๋ฅ ์ฌ์ฌ ๊ฒฐ๊ณผ์ ๋ฉด์ ์ฑ์ ์ด ๋ชจ๋ ๋จ์ด์ง๋ค๋ฉด A๋ ๊ฒฐ์ฝ ์ ๋ฐ๋์ง ์๋๋ค.
์ด๋ฌํ ์กฐ๊ฑด์ ๋ง์กฑ์ํค๋ฉด์, ์ง์ ์ฃผ์ํ์ฌ๊ฐ ์ด๋ฒ ์ ๊ท ์ฌ์ ์ฑ์ฉ์์ ์ ๋ฐํ ์ ์๋ ์ ์ ์ฌ์์ ์ต๋ ์ธ์์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์๋ ํ ์คํธ ์ผ์ด์ค์ ๊ฐ์ T(1 ≤ T ≤ 20)๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ํ ์คํธ ์ผ์ด์ค์ ์ฒซ์งธ ์ค์ ์ง์์์ ์ซ์ N(1 ≤ N ≤ 100,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ ์ค์๋ ๊ฐ๊ฐ์ ์ง์์์ ์๋ฅ์ฌ์ฌ ์ฑ์ , ๋ฉด์ ์ฑ์ ์ ์์๊ฐ ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ํ ์ค์ ์ฃผ์ด์ง๋ค. ๋ ์ฑ์ ์์๋ ๋ชจ๋ 1์๋ถํฐ N์๊น์ง ๋์์ฐจ ์์ด ๊ฒฐ์ ๋๋ค๊ณ ๊ฐ์ ํ๋ค.
์ถ๋ ฅ
๊ฐ ํ ์คํธ ์ผ์ด์ค์ ๋ํด์ ์ง์ ์ฃผ์ํ์ฌ๊ฐ ์ ๋ฐํ ์ ์๋ ์ ์ ์ฌ์์ ์ต๋ ์ธ์์๋ฅผ ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค.
๐ง ํ์ด
์ด ๋ฌธ์ ๋ ๊ทธ๋ฆฌ๋(ํ์) ๋ฌธ์ ์ด๋ค.
์ง์์๋ค์ ๊ฐ์ ์๋ฅ, ๋ฉด์ ์ ์์๊ฐ ์๋ค.
๋ฌธ์ ์์ ์ฃผ์ด์ง ์กฐ๊ฑด์ ' ๋ค๋ฅธ ๋ชจ๋ ์ง์์์ ๋น๊ตํ์ ๋ ์๋ฅ์ฌ์ฌ ์ฑ์ ๊ณผ ๋ฉด์ ์ํ ์ฑ์ ์ค ์ ์ด๋ ํ๋๊ฐ ๋ค๋ฅธ ์ง์์๋ณด๋ค ๋จ์ด์ง์ง ์๋ ์๋ง ์ ๋ฐํ๋ค๋ ์์น' ์ด ์๋ค.
์๋ฅ ์ฑ์ ๊ณผ ๋ฉด์ ์ฑ์ ์ ๋ชจ๋ ๋น๊ตํด์ผ ํ๊ธฐ ๋๋ฌธ์, ์ฐ์ ๋๋ ์๋ฅ ์ฑ์ ์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ์ ํ๋ค.
1. ์๋ฅ ์ฑ์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ
2. ๋ฐ๋ณต๋ฌธ์ ํตํด ๊ฐ ์ง์์๋ค์ ๋ฉด์ ์ฑ์ ๋น๊ตํ๊ธฐ
3. ๋ง์ฝ, i๋ฒ์งธ ์ง์์์ ์ฑ์ ์ด i+1๋ฒ์งธ ์ง์์์ ์ฑ์ ๋ณด๋ค ๋์ ๊ฒฝ์ฐ์๋ i+1๋ฒ์งธ ์ง์์๋ ์ ๋ฐ๋์ง ์๋๋ค. (์๋ฅ, ๋ฉด์ ๋ ๋ค ๋ฎ๊ธฐ ๋๋ฌธ)
import sys
input = sys.stdin.readline
T = int(input())
for i in range(T) :
N = int(input())
p = [list(map(int, input().split())) for _ in range(N)]
p.sort()
t = 0
cnt = 1
for x in range(1, N) :
if (p[x][1] < p[t][1]) :
t = x
cnt += 1
print(cnt)