加分二叉树+最优贸易//信竞==心经

[NOIP2003 提高组] 加分二叉树 

#include
using namespace std;
int n,v[100],dp[100][100],root[100][100];
int dfs(int l,int r)
{
	if(dp[l][r]>0) return dp[l][r];
	if(l==r) return v[l];
	if(rdp[l][r])
		{
			dp[l][r]=p;
			root[l][r]=i;
		}
	}
	return dp[l][r];
}
void print(int l,int r)
{
	if(r

[NOIP2009 提高组] 最优贸易 

鉴于上次的惨痛教训，我终于开始写快读了？然鹅还是躲不掉坑。。。看到最优贸易我就想该怎么绕开一个一个点来DP这件事-->可以强连通分量内缩点诶，那么同一强连通分量中的最大收益就是这个分量中的最大值减去最小值，同时这个图变成了有向无环图。

可能是打ACM的时候天天想怎么绕开问题直接求解，现在本蒟蒻看什么都想圆润地绕开，但是我忽略了一个客观事实：tarjan长度惊人啊。真的真的就几乎只套了个板子就125行 ··_··中间调试的时候一度达到140行，当时我的内心是崩溃的啊啊啊  我的板子（tarjan）

还有一点：DAG上的DP用数组存简直是在挑战MLE的权威，所以不得已只好用队列暴力转移+链式前向星。

我的代码：

#include
using namespace std;
int read()
{
	int f=1,x=0;
	char ch;
	do
	{
		ch=getchar();
		if(ch=='-') f=-1;
	}
	while(ch<'0'||ch>'9'); 
	do
	{
		x=x*10+ch-'0';
		ch=getchar();
	}
	while(ch>='0'&&ch<='9');	 
	return f*x;
}
const int M=500010;
int n,m,into[M],out[M],head[M],cnt;
int dfn[M],low[M],scc_num[M],scc_cnt,vis[M],s[M],top,f[M];
int minn[M],maxx[M],a[M],x[M],y[M];
struct edge
{ int to,next; } e[M];

void add_edge(int u,int v)
{
	e[++cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}

void tarjan(int u)
{
	dfn[u]=low[u]=++cnt;
	vis[u]=1;
	s[++top]=u;
	for(int i=head[u]; i; i=e[i].next)
	{
		int v=e[i].to;
		if(!dfn[v])
		{
			tarjan(v);
			low[u]=min(low[u],low[v]);
		}
		else if(vis[v]) low[u]=min(low[u],dfn[v]);
	}
	if(low[u]==dfn[u])
	{
		scc_cnt++;
		while(s[top+1]!=u)
		{
			scc_num[s[top]]=scc_cnt;
			minn[scc_cnt]=min(minn[scc_cnt],a[s[top]]);
			maxx[scc_cnt]=max(maxx[scc_cnt],a[s[top]]);
			vis[s[top--]]=0;
		}
	}
}

void work(int tag)
{
	queueq;
	q.push(scc_num[tag]);
	f[scc_num[tag]]=max(f[scc_num[tag]],maxx[scc_num[tag]]-minn[scc_num[tag]]);
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		for(int i=head[u]; i; i=e[i].next)
		{
			int v=e[i].to;
			into[v]--;
			minn[v]=min(minn[v],minn[u]);
			f[v]=max(max(f[u],maxx[v]-minn[v]),f[v]);
			if(!into[v]) q.push(v);
		}
	}
}

int main()
{
	n=read();
	m=read();
	for(int i=1; i<=n; i++) a[i]=read();
	for(int i=1; i<=m; i++)
	{
		int u,v,dic;
		u=read();
		v=read();
		dic=read();
		if(dic==1)
		{
			add_edge(u,v);
			x[cnt]=u;
			y[cnt]=v;
		}
		if(dic==2)
		{
			add_edge(u,v);
			add_edge(v,u);
		}
	}
	m=cnt;
	memset(minn,1e6,sizeof minn);
	memset(maxx,-1e6,sizeof maxx);
	for(int i=1;i<=n;i++) if(!dfn[i]) tarjan(i);
	memset(head,0,sizeof head);
	memset(e,0,sizeof e);
	for(int i=1;i<=m;i++)
	{
		if(scc_num[x[i]]!=scc_num[y[i]])
		{
			add_edge(scc_num[x[i]],scc_num[y[i]]);
			into[scc_num[y[i]]]++;
		}
	}
	work(1);
	printf("%d",f[scc_num[n]]);
	return 0;
}

以上代码虽然水过了，但也只是水过了——如果有点无法从1到达呢？不知道。

所以翻题解看正解：。。。32行搞定^_^  然后逐渐发现这是一道宝藏题，其做法包含但不限于：tarjan+缩点，双向SPFA，堆优化+dijktra，BFS，BFS+SPFA，DFS+DP，拓扑排序，甚至还有并查集、万能的哈希。图论题果然离谱。

第二版代码来自咕咕第一篇题解：（可以感受到正确性，但是又没那么显然）

#include
using namespace std;
const int M=100010;
vectorq[M];
int n,m,f[M],minn[M],a[M];
void dfs(int x,int mn,int last)
{
	int flag=1;
	mn=min(a[x],mn);
	if (minn[x]>mn)
	{
		minn[x]=mn;
		flag=0;
	}
	int maxx=max(f[last],a[x]-mn);
	if (f[x]

插一句[BJWC2008]雷涛的小猫 那啥，开数组一开始只开到2000，但考虑数的高度同样要处理所以应该开到 Ni 才不会RE