class Solution {
public:
    vector<int> findNumbersWithSum(vector<int>& nums, int target) {
        for(int i = 0;i < nums.size() - 1;i ++)
            for(int j = i + 1;j < nums.size();j ++)
                if(nums[i] + nums[j] == target)
                    return {nums[i],nums[j]};
        return {-1,-1};
    }
};

class Solution {
public:
    int findMin(vector<int>& nums) {
        return sort(nums.begin(),nums.end()),(nums.size() ? nums[0] : -1);
    }
};

#include <iostream>
using namespace std;
const int N = 100010;
int p[N];
int find(int x)
{
    if(p[x] != x)
        p[x] = find(p[x]);
    return p[x];
}
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i = 1;i <= n;i ++)
        p[i] = i;
    while(m --)
    {
        char c;
        cin>>c;
        int a,b;
        cin>>a>>b;
        if(c == 'M')
            p[find(a)] =find(b);
        else
        {
            if(find(a) == find(b))
                puts("Yes");
            else
                puts("No");
        }
    }
    return 0;
}

是的这篇分享非常短小
我们来看看定义小根堆用的greater<>到底是个什么东西
翻到官网,看到如下定义:

template <class T> struct greater {
  bool operator() (const T& x, const T& y) const {return x>y;}
  typedef T first_argument_type;
  typedef T second_argument_type;
  typedef bool result_type;
};

说白了吧,就是对于传入的类型T重载了括号,定义成了大于号
C++作者真无聊…
好的这次分享就到这里,下次再见

是的这确实跟怪异，但是也确实可以
比如说我们定义一个数据类型Orz
定义函数框架如下（自行完善）:

class Orz {
private:
    ......
public:
    ......
};

好的那么怎么输入输出我们的Orz类型呢？
首先定义一个Orz类型的变量a

Orz a;

重载输入:

friend istream &operator >> (istream &in,Orz &va)
{
    in>>va.val;
    return in;
}

这是不是很简单，是的，就是这样

同理，输出长这样:

friend ostream &operator >> (ostream &out,Orz &va)
{
    out<<va.val;
    return out;
}

好的，到这里，我们的Orz就重载完成了
自己去试试吧（提示:重载必须是在public里，否则会报错）