構造函數與重載運算符

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];
           

 内構函數指派

struct node
{
    int x,y,num,step;   //坐标、時間、藥,路
    node(int x,int y,int num,int step):x(x),y(y),num(num),step(step) {}
    friend bool operator<(node a,node b)
    {
        if(a.step!=b.step)
        return a.step>b.step;
        return a.num>b.num;
    }
};
           

結構體指派初值

struct node
{
    int x;
    int cnt;
    node()
    {
        x=0;
        cnt=0;
    }
}pre[MAXN];