（状压dp/floyd）LibreOJ6177送外卖2

题目：

一张 n 个点 m条有向边的图上，有 q个配送需求，需求的描述形式为 (si,ti,li,ri)，即需要从点 si送到 ti， 在时刻 li之后（包括 li ）可以在 si领取货物，需要在时刻 ri之前（包括 ri）送达 ti，每个任务只需完成一次。

图上的每一条边均有边权，权值代表通过这条边消耗的时间。在时刻 0 有一个工作人员在点 1上，求他最多能完成多少个配送任务。

在整个过程中，可以认为领货跟交货都是不消耗时间的，时间只花费在路程上。当然在一个点逗留也是允许的。

第一行，三个正整数 n,m,q(2≤n≤20,1≤m≤400,1≤q≤10)。
接下来 m行，每行三个正整数 ui,vi,ci(1≤ui,vi≤n,1≤ci≤20000)，表示有一条从 ui到 vi耗时为 ci的有向边。
接下来 q行，每行四个正整数 si,ti,li,ri(1≤si,ti≤n,1≤li≤ri≤106)，描述一个配送任务。

这是一道状态压缩的题目，同时也考察了 floyd 算法的应用，是一道比较综合的题。

由于考虑到 q 的范围很小，所以有可能运用状压dp，但是有个问题，在题目中一个订单有三种状态，未接受，在手里，和已送达，而我们状态压缩用二进制只能表示 0 和 1，这时可以考虑用 2 进制实现的 4 进制，两位表示一个数，所有操作翻一倍，但这种方法略微有点麻烦，所以选用一种用数组存 3 的多少次方表示第几位的方法，具体方法在下面会讲。又因为考虑到在转移的过程当中一定会用到任意两点之间的最短距离，所以想到可能会用 floyd 算法，这样前期的准备工作就做完了。

这时考虑方程，此时注意，题目上的意思有可能可以同时跑多份订单，所以状压dp就更合适了，而且考虑到时间有可能出现的问题，采用从当前状态往后推的方法，因为若是往前推，你不知道开始时间是多少。

f [ i ][ s ]表示当前在 i，订单状态为 s 所用的最小时间，因为此题的时空限制非常小，而且从 s 里面就可以得出得到了几个订单，所以就把时间存在 f 的值里这样既省了枚举又省了数组美滋滋。

我用 p 存的是三进制，task存的是 q 的任务，dis [ i ][ j ]表示 i 到 j 的最短路径。

用 f [ i ][ s ] + dis [ i ][ task[ k ].s ] 和 task[ k ].l 的最大值来更新 f [ task[ k ].s ][ s + p[ k ] ]，条件为第 k 个配送还未接取。

上面的意思为：当前外卖小哥哥在 i 点，他要去接 k 这个任务，所以接完任务后，他会站在 task[ k ].s 的位置上仰望星空，而他当前的外卖清单上就会多出一条任务 k 当然，小哥哥接任务的时间不一定，有时是小哥哥推了门进店后大声喊了订单号发现还没做好，于是在这个点上等到了订单做好的时间再走，还有一种可能，就是卖家已将订单做好，系上塑料袋放在那等小哥哥来取，这时小哥哥来到店里后拿到外卖就跑所以用 f [ i ][ s ] + dis [ i ][ task[ k ].s ] 和 task[ k ].l 的最大值。

用 f [ i ][ s ] + dis [ i ][ task[ k ].t ]来更新 f [ task[ k ].t ][ s + p[ k ] ]，条件是第 k 份外卖在兜里并且 f [ i ][ s ] + dis [ i ][ task[ k ].t ] <= task[ k ].r。

上面的意思为：当前小哥哥在 i 点，他要去送 k 这个订单，所以送完订单后，他会在 task[ k ].t 的位置上放飞自我，而他当前的外卖清单上就会把k这条画上一个完美的句号，当然，小哥哥必须在买主不乐意之前把外卖送到，所以多出了上面那个条件，小哥哥会从 i 这个位置上跑到 task[ k ].t 所以时间加上这个。

若当前这个任务画上了句号，那么会在可以达成的任务上加一，最后把所有能达成的情况打个擂台就可以。

代码写得贼吉儿难看，理解下大意就点叉吧。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,m,q;
int v[500];
int nxt[500];
struct node
{
    int to,val;
}edge[500];
int edge_num=0;
int INF;
struct rw
{
    int s,t,l,r;
}task[20];
int dis[25][25];
int f[25][60000];
int p[25];
int ans=0;
/*inline void addedge(int a,int b,int c)
{
    edge[++edge_num].to=b;
    edge[edge_num].val=c;
    nxt[edge_num]=v[a];
    v[a]=edge_num;
}*/
inline void getdata()
{
    memset(dis,63,sizeof(dis));
    int a,b,c;
    scanf("%d%d%d",&n,&m,&q);
    for(int i=1;i<=m;++i)
    {
        scanf("%d%d%d",&a,&b,&c);
        addedge(a,b,c);
        dis[a][b]=min(dis[a][b],c);
    }
    for(int i=1;i<=q;++i)
    {
        scanf("%d%d%d%d",&task[i].s,&task[i].t,&task[i].l,&task[i].r);
    }
}
inline void floyd()
{
    for(int i=1;i<=n;i++)
    {
        dis[i][i]=0;
    }
    //cout<<dis[3][5]<<" ";
    for(int k=1;k<=n;++k)
    {
        for(int i=1;i<=n;++i)
        {
            for(int j=1;j<=n;++j)
            {
                dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
            }
        }
    }
}
inline void tjz()
{
    p[1]=1;
    for(int i=2;i<=q;i++)
    {
        p[i]=p[i-1]*3;
        //cout<<"{"<<i<<" "<<p[i]<<"}";
    }
}
inline void fs()
{
    memset(f,63,sizeof(f));INF=f[1][1];
    f[1][0]=0;
    //cout<<"GGGGGGGGG"<<p[q]<<"KKKKKKKKKk";
    for(int s=0;s<p[q]*3;++s)
    {
        for(int i=1;i<=n;++i)
        {
            if(f[i][s]!=INF)
            {
                int tot=0;
                for(int k=1;k<=q;k++)
                {
                    int w=s/p[k]%3;
                    if(w==0)
                    {
                        f[task[k].s][s+p[k]]=min(f[task[k].s][s+p[k]],max(f[i][s]+dis[i][task[k].s],task[k].l));
                    }
                    else if(w==1)
                    {
                        if(f[i][s]+dis[i][task[k].t]<=task[k].r)
                            f[task[k].t][s+p[k]]=min(f[task[k].t][s+p[k]],f[i][s]+dis[i][task[k].t]);
                    }
                    else tot++;
                }
                //cout<<"{"<<i<<" "<<s<<" "<<f[i][s]<<" "<<tot<<"}";
                ans=max(ans,tot);
            }
        }
    }
}
int main()
{
    //freopen("takeout.in","r",stdin);
    //freopen("takeout.out","w",stdout);
    getdata();
    floyd();
    tjz();
    //cout<<"("<<dis[1][2]<<")";
    fs();
    //cout<<"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$";
    printf("%d",ans);
    /*for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            cout<<"{"<<i<<" "<<j<<" "<<dis[i][j]<<"}";
        }
    }*/
    /*for(int k=1;k<=q;++k)
    {
        for(int i=0;i<=maxtim;++i)
        {
            for(int j=1;j<=n;++j)
            {
                cout<<"("<<i<<" "<<j<<" "<<k<<" "<<f[i][j][k]<<")";
            }
        }
    }*/
    return 0;
}

以下来讲一讲三进制的表示方法

可以和二进制一样用整数来表示，而你要取哪位，就把这个整数整除那位的 p 值在 mod 3 就可以了，而这个东西自带加法进位，这就是上面那个方程写成那个样子的原因

以下为一个蒟蒻答此题时的悲惨经历

总共考了4道题，我把所有精力都铺在这道题上，妄想着要得100分，当然那是不可能的，没有关注到范围特小就没用状态压缩，而且整个想错了以为小哥哥一次只能接一份，还自以为是的按时间排了序，结果样例过了，然而自己取OJ交只A了两个点，各种TWAM，最悲惨的是在同学的评测机上评爆零了，老师因为这事还发了通火，我就不争气的哇的一声了，后来同学告诉我他测试数据就是从那个oj上下的，我：？？？？？