一个无向图，可能有自环，有重边，每条边有一个边权。你可以从任何点出发，任何点结束，可以经过同一个点任意次。但是不能经过同一条边2次，并且你走过的路必须满足所有边的权值严格单调递增，求最长能经过多少条边。

 

 

以此图为例，最长的路径是：

3 -> 1 -> 2 -> 3 -> 2 或

3 -> 1 -> 2 -> 3 -> 4 长度为4。

6 8

0 1 4

1 2 3

1 3 2

2 3 5

3 4 6

4 5 6

5 0 8

3 2 7

4

#include<bits/stdc++.h>

using namespace std;

typedef pair<int,int> P;

const int maxn=;

int Laxt[maxn],Next[maxn],To[maxn],cost[maxn],cnt;

P lin[maxn]; int l[maxn],r[maxn],dis[maxn],ans;

void add(int u,int v,int c)

{

    Next[++cnt]=Laxt[u];

    Laxt[u]=cnt; To[cnt]=v;

    cost[cnt]=c;

}

int main()

{

    int N,M,u,v,c,i,j;

    scanf("%d%d",&N,&M);

    for(i=;i<=M;i++){

        scanf("%d%d%d",&l[i],&r[i],&c);

        add(l[i],r[i],c);  add(r[i],l[i],c);

        lin[i]=P(c,i);

    }

    sort(lin+,lin+M+);

    for(i=;i<=cnt;i++) dis[i]=;

    for(i=;i<=M;i++){

        int Ln=lin[i].second,Ct=lin[i].first;

        for(j=Laxt[l[Ln]];j;j=Next[j]){

            if(cost[j]>Ct) {

                dis[j]=max(dis[j],dis[*Ln]+);

                ans=max(ans,dis[j]);

            }

        }

        for(j=Laxt[r[Ln]];j;j=Next[j]){

            if(cost[j]>Ct) {

               dis[j]=max(dis[j],dis[*Ln-]+);

               ans=max(ans,dis[j]);

            }

        }

    }

    printf("%d\n",ans);

    return ;

}

/*

2 4

0 1 1

1 0 2

0 1 3

1 0 4

*/