CF576D. Flights for Regular Customers

n<=150个点，m<=150条路，每条路Ai,Bi,Di表示Ai到Bi有一条有向边，使用他前至少要走Di条路，问1到n最少走几条路。

又是n^4过150的题。。。。

不同于传统的最短路，这次的最短路包括了m个图，并且状态和走的路径数有关。所以要一个状态Can(i,j)表示能否到达点i走j步。

由于有m个图，我们就一个一个图来看。把边从小到大加入图，每加入某个值的一组边即可构成一个新图。在进入一个新图之前，我需要知道：在上个图的最后一步，从1走能走到哪些点，已这些点为起点进行下一步的探索。新来一个图之后，先尝试在这个图上走 不进入下个图的边数，能不能走到n点，如果能输出答案，不能就记这个图最后能从一到达哪些点然后进行下一步扩展。而尝试找能否走到n点，不可能从C(i,Dj)一路推到C(i,Dj+1)这里的D排序好了，所以需要一个倍增floyd。

然而这样的话是m*n*n*n*logMax，咋整？floyd用bitset优化！m*n*n*n*logMax/32大概就是n^4啦

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<stdlib.h>
#include<bitset>
//#include<math.h>
//#include<iostream>
using namespace std;

int n,m;
#define maxn 161
struct Mat
{
    bitset<maxn> a[maxn];
    void clear() {for (int i=1;i<=n;i++) a[i].reset();}
    Mat operator * (const Mat &b)
    {
        Mat ans;
        for (int j=1;j<=n;j++)
            for (int i=1;i<=n;i++)
                if (a[i][j]) ans.a[i]|=b.a[j];
        return ans;
    }
    Mat operator ^ (const Mat &b)
    {
        Mat ans;
        for (int j=1;j<=n;j++)
            for (int i=1;i<=n;i++)
                if (a[i][j]) ans.a[i]|=b.a[j];
        for (int i=1;i<=n;i++) ans.a[i]|=a[i];
        return ans;
    }
}mp,f[33],base;

struct Point
{
    int a,b,d;
    bool operator < (const Point &b) const {return d<b.d;}
}p[maxn];
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++) scanf("%d%d%d",&p[i].a,&p[i].b,&p[i].d);
    sort(p+1,p+1+m);
    if (p[1].d) {puts("Impossible");return 0;}
    p[m+1].d=0x3f3f3f3f;
    base.a[1][1]=1;
    for (int i=2;i<=m+1;i++)
    {
        while (i<=m+1 && p[i].d==p[i-1].d) {mp.a[p[i-1].a][p[i-1].b]=1; i++;}
        int j,num=p[i].d-p[i-1].d;
        for (j=30;j>=0;j--) if ((1<<j)<=num) break;
        f[0]=mp;
        for (int k=1;k<=j;k++) f[k]=f[k-1]^f[k-1];
        Mat now; now=base; int cnt=0;
        for (int k=j;k>=0;k--) if (cnt+(1<<k)<=num)
        {
            Mat tmp;tmp=now^f[k];
            bool flag=0;
            for (int l=1;l<=n;l++) flag|=tmp.a[l][n];
            if (!flag) cnt+=(1<<k),now=tmp;
        }
        if (cnt!=num) {printf("%d
",p[i-1].d+cnt+1);return 0;}
        else
        {
            f[0]=mp;
            for (int k=1;k<=j;k++) f[k]=f[k-1]*f[k-1];
            cnt=0;
            for (int k=j;k>=0;k--) if (cnt+(1<<k)<=num) base=base*f[k],cnt+=(1<<k);
            Mat tmp; tmp=base;
            base.clear();
            for (int k=1;k<=n;k++)
                for (int l=1;l<=n;l++)
                    if (tmp.a[k][l]) base.a[l][l]=1;
        }
    }
    puts("Impossible");
    return 0;
}