[JZOJ3430] DY引擎

Description

BOSS送给小唐一辆车。小唐开着这辆车从PKU出发去ZJU上课了。

众所周知，天朝公路的收费站超多的。经过观察地图，小唐发现从PKU出发到ZJU的所有路径只会有N（2<=N<=300）个不同的中转点，其中有M（max(0, N-100) <=M<=N）个点是天朝的收费站。N个中转点标号为1…N，其中1代表PKU，N代表ZJU。中转点之间总共有E（E<=50,000）条双向边连接。

每个点还有一个附加属性，用0/1标记，0代表普通中转点，1代表收费站。当然，天朝的地图上面是不会直接告诉你第i个点是普通中转点还是收费站的。地图上有P（1<=P<=3,000）个提示，用[u, v, t]表示：[u, v]区间的所有中转点中，至少有t个收费站。数据保证由所有标记得到的每个点的属性是唯一的。

车既然是BOSS送的，自然非比寻常了。车子使用了世界上最先进的DaxiaYayamao（博主注：这是什么鬼）引擎，简称DY引擎。DY引擎可以让车子从U瞬间转移到V，只要U和V的距离不超过L（1<=L<=1,000,000），并且U和V之间不能有收费站（小唐良民一枚，所以要是经过收费站就会停下来交完钱再走）。

DY引擎果然是好东西，但是可惜引擎最多只能用K（0<=K<=30）次。

Solution

首先，我们应该先求出收费站

设$Sum[i]$表示$1$~$i$有多少个收费站

显然$0\leq Sum[i]-Sum[i-1]\leq 1$

将其都化成大于等于（小于等于也可以）

$Sum[i]-Sum[i-1]\geq0,Sum[i-1]-Sum[i]\geq1$

别忘了我们还有提示$Sum[v]-Sum[u-1]\geq t$

然后可以用差分约束求出$Sum[i]-Sum[0](Sum[0]=0)$

再来看求距离

$dis[i,j]$表示到$i$点用了$j$次

$sp(b)fa$暴力转移即可

话说N只有300，但是我居然去打前向星（因为这一段我是Copy的）

Code

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cmath>
#define fo(i,a,b) for(i=a;i<=b;i++)
#define fod(i,a,b) for(i=a;i>=b;i--)
using namespace std;
struct note
{
    int x,y,z; 
};
bool cmp(note x,note y)
{
    return x.x<y.x;
}
int n,m,p,l,q,lim,m1;
int a1[301][2],f[301][301],b[301][301],dis[301][31],d[100001][2];
note a[100001];
bool bz[301][31];
void floyd()
{
    int i,j,k;
    fo(k,1,n)
    {
        if (dis[k][0]==0)
        {
            fo(i,1,n)
            {
                fo(j,1,n)
                {
                    f[i][j]=min(f[i][j],f[i][k]+f[k][j]);
                }
            }
        }
    }
}
int SPFA(int st)
{
    int i,j,now;
    memset(bz,0,sizeof(bz));
    i=0;
    j=1;
    d[1][0]=st;
    d[1][1]=0;
    bz[st][0]=1;
    dis[st][0]=0;
    while (i<j)
    {
        i++;
        int k;
        now=d[i][0];
        if (a1[now][0]>0)
        fo(k,a1[now][0],a1[now][1])
        {
            int p=a[k].y;
            if ((dis[p][d[i][1]]<dis[now][d[i][1]]+a[k].z&&st==0)||(dis[p][d[i][1]]>dis[now][d[i][1]]+a[k].z&&st==1))
            {
                dis[p][d[i][1]]=dis[now][d[i][1]]+a[k].z;
                if (bz[p][d[i][1]]==0) 
                {
                    d[++j][0]=p;
                    d[j][1]=d[i][1];
                    bz[p][d[i][1]]=1;
                }
            }
        }
        if (st==1)
        {
            fo(k,1,n)
            {
                if (k!=now&&f[now][k]<=l&&d[i][1]<lim&&dis[k][d[i][1]+1]>dis[now][d[i][1]])
                {
                    dis[k][d[i][1]+1]=dis[now][d[i][1]];
                    if (bz[k][d[i][1]+1]==0) 
                    {
                        d[++j][0]=k;
                        d[j][1]=d[i][1]+1;
                        bz[k][d[j][1]]=1;
                    }
                }
            }
        }
        bz[now][d[i][1]]=0;
    }
}
int main()
{
    cin>>n>>p>>m>>q>>l>>lim;
    m1=0;
    a[++m1].x=0;
    a[m1].y=1;
    a[m1].z=0;
    int i,j;
    fo(i,1,n)
        fo(j,1,n)
        {
            f[i][j]=1e+8;
        }
    fo(i,1,m)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        f[x][y]=f[y][x]=min(f[x][y],z);
    }
    fo(i,2,n)
    {
        a[++m1].x=i-1;
        a[m1].y=i;
        a[m1].z=0;
        a[++m1].x=i;
        a[m1].y=i-1;
        a[m1].z=-1;  
    }
    fo(i,1,q)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        a[++m1].x=x-1;
        a[m1].y=y;
        a[m1].z=z;
    }
    memset(dis,255,sizeof(dis));
    sort(a+1,a+m1+1,cmp);
    a1[0][0]=a1[0][1]=1;
    fo(i,2,m1)
    {
        if (a[i].x!=a[i-1].x)
        {
            a1[a[i].x][0]=i;
            a1[a[i-1].x][1]=i-1;
        }
    }
    a1[a[m1].x][1]=m1;
    SPFA(0);
    fod(i,n,1) dis[i][0]-=dis[i-1][0];
    m1=0;
    fo(i,1,n)
    {
        fo(j,1,n) 
        {
            if (f[i][j]!=1e+8&&i!=j) 
            {
                a[++m1].x=i;
                a[m1].y=j;
                a[m1].z=f[i][j];    
            } 
        } 
    }
    sort(a+1,a+m1+1,cmp);
    fo(i,1,m1)
    {
        if (a[i].x!=a[i-1].x)
        {
            a1[a[i].x][0]=i;
            a1[a[i-1].x][1]=i-1;
        }
    }
    a1[a[m1].x][1]=m1;
    floyd();
    memset(dis,107,sizeof(dis));
    SPFA(1);
    int ans=1000000000;
    fo(i,0,lim) ans=min(ans,dis[n][i]);
    cout<<ans;
}