构造函数与重载运算符

struct Node
{
	int l,r;
    friend bool operator <(Node a,Node b)  //两个参数至少有一个是类里面的才可以省略friend
    {
        return a.r>b.r;      //因为就是将r小的在优先队列优先删除，和l无关
    }
}f[MAX];                     //优先队列return >就是从小到大排列

struct Matrix         //矩阵乘法floyd
{
    int a[MAXN][MAXN];
    Matrix operator *(const Matrix &x) const
    {
        Matrix c;
        memset(c.a,INF,sizeof(c.a));
        for (int k=1;k<=tn;k++)
            for (int i=1;i<=tn;++i)
                for (int j=1; j<=tn; ++j)                           //这个是单步Floyd,一次插入一个点
                    c.a[i][j] = min(c.a[i][j],a[i][k]+x.a[k][j]);   //矩阵乘法Floyd与正常的区别：
                                                                    //1.没有对原数组进行更新，即原来的两点距离并没有改变
        return c;                                                   //由第一点的区别可以推出第二点的区别
                                                                    //2.一定是加一个点，添一条边
                                                                    //一般的Floyd可能加一个点，添多条边，因为他不断dp,记录了之前的最优
                                                                    //而最优可能不是两点的直接路径，有可能是加点的转达，这样就造成了
                                                                    //加一个点添多条边
     }
}str,ans;

struct data
{
    int val[2];
    data operator +(const data &rhs)const      //const是必备的
    {                                          //第一餐参数是有this指针指的，所以val[]可以在构造函数中用
        int i;                                 //还需要注意不在构造函数定义的参数是不能改变的。
        int t_val[2]={val[0],val[1]};
        for(i=0;i<2;i++)
        {
            if(rhs.val[i]>t_val[0])
            {
                t_val[1]=t_val[0];             //t_val[0]存的是最大的数
                t_val[0]=rhs.val[i];           //t_val[1]存的是第二大的数
            }
            else if(rhs.val[i]>t_val[1])
            t_val[1]=rhs.val[i];
        }
        return data{t_val[0],t_val[1]};       //这个+的功能就是取两个结构体中最大的数和第二大的数
    }
}dp[(1<<20)+10];