这个题好像有一万种解法，有spfa双向扩搜的，有分层图转移的，bfs的。。。。。
题目描述：
n个点m条边，每个点有一个权值代表在这个点买或者卖水晶球的价格
有一个人从1走到n问你能够赚的最多的差价是多少（只能买卖一次）
题目思路：
这是一个带环的有向图
首先可以把环缩成一个点，记录这个点的买卖的最高价格和最低价格
（因为对于一个环内所有的点，这些点可以相互到达）
那么现在图就变成了一个DAG
对于当前点u满足
dp[u] = max(max(dp[u],dp[v]),val_max[u]-minn[v]);
其中max(dp[u],dp[v])记录能够到达n点的路径上的最大差值
一开始推成了dp[v] =val_max[v] - minn[v];
然后扫了一边取最大值
这样有可能最后到达的那个点并不是n点
Code：
int head[maxn],cnt,n,m,val[maxn],vis[maxn],dfn[maxn],low[maxn],indexx,minn[maxn];
int block,id[maxn],cnt1,head1[maxn],in[maxn],valma[maxn],valmi[maxn],dp[maxn];
stack<int>st;
struct node {
int u,v,next;
} e[maxn],zan[maxn];
void add1(int u,int v ) {
zan[cnt1].u=u;
zan[cnt1].v=v;
zan[cnt1].next=head1[u];
head1[u]=cnt1++;
}
void add(int u,int v ) {
e[cnt].u=u;
e[cnt].v=v;
e[cnt].next=head[u];
head[u]=cnt++;
}
void tarjan(int u) {
dfn[u] = low[u] = ++indexx;
vis[u] = 1;
st.push(u);
for(int i=head1[u]; ~i; i=zan[i].next) {
int v = zan[i].v;
if(dfn[v]==0) tarjan(v), low [u] = min(low[u],low[v]);
else if(vis[v]) low[u] = min(low[u],dfn[v]);
}
int ma = -inf,mi = inf;
if(low[u] == dfn[u]) {
int yy;
block++;
do {
yy = st.top();
st.pop();
vis[yy] =0 ;
ma =max(ma,val[yy]);
mi =min(mi,val[yy]);
id[yy] = block;
} while(yy!=u);
valmi[block] = mi;
valma[block] = ma;
}
}
void top_sort() {
queue<int>q;
q.push(id[1]);
while(q.size()) {
int u = q.front();
q.pop();
for(int i =head[u]; ~i; i=e[i].next) {
int v = e[i].v;
minn[v] = min (minn[u],valmi[v]);
dp[v] = max(max(dp[u],dp[v]),valma[v]-minn[v]);
in[v]--;
if(in[v]==0) q.push(v);
}
}
}
int main() {
mst(head1,-1);
n=read(),m=read(),mst(head,-1);
rep(i,1,n) val[i] = read(),minn[i] = inf;
for(int i=1 ; i<=m ; i++) {
int op,u,v;
u=read(),v=read(),op=read();
add1(u,v);
if(op==2) add1(v,u);
}
tarjan(1);
for(int i = 0 ; i<cnt1 ; i++) {
int u = zan[i].u;
int v = zan[i].v;
if(id[u]!=id[v]) add(id[u],id[v]),in[id[v]]++;
}
top_sort();
out(dp[id[n]]);
return 0;
}