DP_最长递增路径

题意：

1274 最长递增路径

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

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

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

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

输入
第1行：2个数N, M，N为节点的数量，M为边的数量(1 <= N <= 50000, 0 <= M <= 50000)。节点编号为0 至 N - 1。
第2 - M + 1行：每行3个数S, E, W，表示从顶点S到顶点E，有一条权值为W的边(0 <= S, E <= N - 1, 0 <= W <= 10^9)。

输出
输出最长路径的长度。

输入样例
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

思路：

状态：
dp[u][0]表示这一组以u节点为终点的最长路径长度
dp[u][1]表示上一组以u节点为终点的最长路径长度

状态转移方程：
dp[v][0] = max(dp[v][0],dp[u][1] + 1)

要求：
从任何点出发，任何点结束，可以经过同一个点任意次。但是不能经过同一条边2次，并且你走过的路必须满足所有边的权值严格单调递增。

问题是怎么满足要求呢：
我们对所有边按照边权从大到小排序，因为是严格递增得，所以相同的边权相同的处理，在一起处理嘛。。。
代码：

while(G[r].w == G[r + 1].w) r++;
		for(int j = l;j <= r;j++){
			int u = G[j].u;
			int v = G[j].v;
			dp[u][0] = max(dp[u][0],dp[v][1] + 1);
			dp[v][0] = max(dp[v][0],dp[u][1] + 1);
		}

最后千万注意边界问题，我们的边界是 l 和 r ，不要乱搞变量。。。最终还是太菜了。。。

完整代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<stack>
#include<queue>
#include<string>
#include<cmath>
#include<map>
#include<set>
#include<vector>
#include<cstdlib>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 5;
struct node{
	int u,v,w;
}G[maxn];
bool cmp(node a,node b){
	return a.w < b.w;
}
int main(){
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i = 1;i <= m;i++){
		scanf("%d%d%d",&G[i].u,&G[i].v,&G[i].w);
	}
	sort(G + 1,G + 1 + m,cmp);
	int dp[maxn][2];
	memset(dp,0,sizeof(dp));
	int l = 1;
	int r = 1;
	int ans = 1;
	for(int l = 1;l <= m;){//边界问题qaq
		while(G[r].w == G[r + 1].w) r++;
		for(int j = l;j <= r;j++){
			int u = G[j].u;
			int v = G[j].v;
			dp[u][0] = max(dp[u][0],dp[v][1] + 1);
			dp[v][0] = max(dp[v][0],dp[u][1] + 1);
		}
		for(int j = l;j <= r;j++){
			int u = G[j].u;
			int v = G[j].v;
			dp[u][1] = dp[u][0];
			dp[v][1] = dp[v][0];
			ans = max(ans,max(dp[u][1],dp[v][1]));
		}
		l = r = r + 1;
	}
	printf("%d\n",ans);
	return 0;
}