Max Rectangle

 #include  
    using namespace std; 
    bool sortby(const pair& a, 
            const pair& b) 
    { 
    if (a.first != b.first) 
        return a.first < b.first; 
    return (a.second < b.second); 
    } 
    bool kOverlap(vector > pairs, int k) 
    { 
    vector > vec; 
    for (int i = 0; i < pairs.size(); i++) { 

        vec.push_back(make_pair( pairs[i].first, -1 )); 
        vec.push_back(make_pair( pairs[i].second, +1 )); 
    } 
    sort(vec.begin(), vec.end()); 
    stack > st; 
    for (int i = 0; i < vec.size(); i++) { 
        pair cur = vec[i]; 
        if (cur.second == -1) { 
            st.push(cur); 
        } 
        else { 
            st.pop(); 
        } 
        if (st.size() >= k) { 
            return true; 
        } 
    } 
    return false; 
    } 
     int main()
    {  
    int t;
    cin>>t;
    while(t--)
    {
    int n,k;
    cin>>n>>k;
    vector > pairs; 
    int x,y;
    for(int i=0;i>x>>y;
        pairs.push_back(make_pair(x,y));
    }
    if(kOverlap(pairs,k))
    cout<<"Yes"<

						 

import java.util.*;

class maxRectangle 
{
	static int maxHist(int R, int C, int row[])
	{
		/* Create an empty stack. The stack holds indexes of
           hist[] array/ The bars stored in stack are always
		   in increasing order of their heights. */
		Stack result = new Stack();

		int top_val; 

		int max_area = 0; 

		int area = 0; 

		// Run through all bars of given histogram (or row)
		int i = 0;
		while (i < C) 
        {
			// If this bar is higher than the bar on top
			// stack, push it to stack
			if (result.empty()
				|| row[result.peek()] <= row[i])
				result.push(i++);
			else {
				/* If this bar is lower than top of stack,
				then calculate area of rectangle with
				stack top as the smallest (or minimum
				height) bar. 'i' is 'right index' for the
				top and element before top in stack is
				'left index' */
				top_val = row[result.peek()];
				result.pop();
				area = top_val * i;

				if (!result.empty())
					area
						= top_val * (i - result.peek() - 1);
				max_area = Math.max(area, max_area);
			}
		}
		/* Now pop the remaining bars from stack and
		calculate area with every popped bar as the smallest bar */
		while (!result.empty()) 
        {
			top_val = row[result.peek()];
			result.pop();
			area = top_val * i;
			if (!result.empty())
				area = top_val * (i - result.peek() - 1);

			max_area = Math.max(area, max_area);
		}
		return max_area;
	}
	// Returns area of the largest rectangle with all 1s in A[][]
	static int max(int R, int C, int A[][])
	{
		// Calculate area for first row and initialize it as result
		int result = maxHist(R, C, A[0]);
		/* iterate over row to find maximum rectangular area
		 considering each row as histogram */
		for (int i = 1; i < R; i++) 
        {
			for (int j = 0; j < C; j++)

				// if A[i][j] is 1 then add A[i -1][j]
				if (A[i][j] == 1)
					A[i][j] += A[i - 1][j];
			// Update result if area with current row (as
			// last row of rectangle) is more
			result = Math.max(result, maxHist(R, C, A[i]));
		}
		return result;
	}
	public static void main(String[] args)
	{
		int R = 4;
		int C = 4;

		int A[][] = {
			{ 0, 1, 1, 0 },
			{ 1, 1, 1, 1 },
			{ 1, 1, 1, 1 },
			{ 1, 1, 0, 0 },
        };
		System.out.print("Area of maximum rectangle is "+ max(R, C, A));
	}
}

def sortby(a, b):

    if (a[0] != b[0]):
        return a[0] < b[0]

    return (a[1] < b[1])


def kOverlap(pairs, k): 
     
    vec = [] 
    for i in range(len(pairs)): 

        vec.append([ pairs[i][0], -1 ])
        vec.append([ pairs[i][1], +1 ])

    vec.sort()
    st = [] 
    for i in range(len(vec)):

        cur = vec[i] 
        
        if (cur[1] == -1):
            st.append(cur) 
        
        else:
            st.pop()

        if (len(st) >= k): 
            return True 

    return False


for _ in range(int(input())):

	n, k =map(int,input().split())
	pairs = []
	for i in range(n):
		pairs.append(list(map(int,input().split())))

	if kOverlap(pairs, k):
		print("Yes")
	else:
		print("No")