easy sorting method

[legendart]

I think this is a simple function to sorting something.
Is here any advices??

input data type is <int, int>.
and input data is stored at source[N].

i want to sorting input data to first column and then second column.

  int FindMax(void)
{
  using data = pair<int, int>;
  priority_queue<data, vector<data>, greater<data>> pq;
  
  for(auto i=0 ; i < N ; i++)
    pq.emplace(make_pair(source[i].first, source[i].second));

  while(!pq.empty())
  {
    auto temp_data = pq.top();
    pq.pop();
    cout << temp_data.first << " " << temp_data.second << endl;
  }
}

[legendart]

And to extend, exchange pair to tuple

[JLBorges]

Since pairs and tuples are LessThanComparable if their members are LessThanComparable,
this would be simpler:

struct S
{
    int first ;
    std::string second ;
    // ..
};

void foo( std::vector<S>& source )
{
    const auto cmp_first_then_second = []( const S& a, const S& b )
    { return std::make_tuple( a.first, a.second ) < std::make_tuple( b.first, b.second ) ; };

    std::sort( std::begin(source), std::end(source), cmp_first_then_second ) ;
}

[legendart]

int bfs(){
    int ans = -1;
    int h, w, time;
    input_data();
    using data = tuple<int, int, int>;
    queue<data> bfs;

    bfs.emplace(make_tuple(0,0,0));

    while(!bfs.empty())
    {
        tie(h, w, time) = bfs.front();
        bfs.pop();
    
        if(h < 0 || h >= H || w < 0 || w >= W)
            continue;
        if(h == H-1 && w == W-1)
        {
            ans = time;
            break;
        }
        if(map[h][w] == '.')
        {
            map[h][w] = 'a';
            bfs.emplace(make_tuple(h-1, w, time+1));
            bfs.emplace(make_tuple(h, w+1, time+1));
            bfs.emplace(make_tuple(h+1, w, time+1));
            bfs.emplace(make_tuple(h, w-1, time+1));
        }
    }
}

[legendart]

// plus,
I make some tree depth check function. Is there any advice?

#include <iostream>
#include <map>
#include <vector>
#include <algorithm>

using namespace std;

int numOfDepth = 0;

void findDepthOfLeaf(multimap<int, int> contactTree, int leaf)
{
	for(auto i = contactTree.begin() ; i != contactTree.end() ; i++)
	{
		if(leaf == i->second)
		{
			findDepthOfLeaf(contactTree, i->first);
			numOfDepth++;
		}
	}
}

int main()
{
	int numOfNode, numOfEdge;
	cin >> numOfNode >> numOfEdge;
	
	multimap<int, int> contactTree;
	for(int i=0 ; i < numOfEdge ; i++)
	{
		int pNode, cNode;
		cin >> pNode >> cNode;
		
		contactTree.insert(pair<int, int>(pNode, cNode));
	}
	
	map<int, int> leafDepthPair;
	
	for(auto i : contactTree)
	{
		auto itr = contactTree.find(i.second);
		if(itr == contactTree.end())
		{
			findDepthOfLeaf(contactTree, i.second);
			leafDepthPair.insert(make_pair(i.second, numOfDepth));
			numOfDepth = 0;
		}
	}
	
	int max=0;
	int min=65535;
	for(auto i : leafDepthPair)
	{
		if(i.second > max) max = i.second;
		if(i.second < min) min = i.second;
	}
	
	if(leafDepthPair.size() == 0) min = 0;
	cout << max - min << endl;
	return 0;
}

[JLBorges]

It would help if you explain how a tree is represented as a std::multimap<int, int>.