【洛谷 P1137】旅行计划——spfa拓展

题目描述

小明要去一个国家旅游。这个国家有N个城市，编号为1～N，并且有M条道路连接着，小明准备从其中一个城市出发，并只往东走到城市i停止。

所以他就需要选择最先到达的城市，并制定一条路线以城市i为终点，使得线路上除了第一个城市，每个城市都在路线前一个城市东面，并且满足这个前提下还希望游览的城市尽量多。

现在，你只知道每一条道路所连接的两个城市的相对位置关系，但并不知道所有城市具体的位置。现在对于所有的i，都需要你为小明制定一条路线，并求出以城市i为终点最多能够游览多少个城市。

输入格式：

输入的第1行为两个正整数N, M。

接下来M行，每行两个正整数x, y，表示了有一条连接城市x与城市y的道路，保证了城市x在城市y西面。

输出格式：

输出包括N行，第i行包含一个正整数，表示以第i个城市为终点最多能游览多少个城市。

数据范围：

对于100%的数据，N ≤ 100000，M ≤ 200000

这道题第一反应dp，一个点的答案就是所有指向它的点中最大的+1,。可是正向dp不是很方便，因为初始点不止一个。

然后我就接触了一个黑科技——记忆化搜索。

本质还是搜索，不过是带动归思想的搜索，剪掉的枝多到不知道那里去了…

搜索过程中先判断该状态有没有记录，如果有就直接返回，如果没有就往下搜索并记录。

效率和dp一样？

代码如下;

#include<cstdio>
#include<iostream>
using namespace std;
struct edge{
int to,next;
}ed[400001];
int head[100001]={0};
int n,m,size=0;
int dp[100001]={0};
void read(int &x)
{
char c=getchar();x=0;
while(c<'0'||c>'9') c=getchar();
while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
}
void add(int from,int to)
{
size++;
ed[size].to=to;
ed[size].next=head[from];
head[from]=size;
}
int dfs(int u)
{
if(dp[u]) return dp[u];
dp[u]=1;
for(int i=head[u];i;i=ed[i].next)
{
int v=ed[i].to;
dp[u]=max(dp[u],dfs(v)+1);
}
return dp[u];
}
int main()
{
read(n),read(m);
for(int i=1;i<=m;i++)
{
int u,v;
read(u),read(v);
add(v,u);
}
for(int i=1;i<=n;i++)
{
printf("%d\n",dfs(i));
}
return 0;
}

另外说一下spfa的方法。

spfa大概是最常用的最短路算法了，重要的不是它的代码，而是它的思想，很多不是求最短路的里的题也可以用“hortest path faster algorithm”/滑稽

spfa是怎么实现的？

每次取出队首元素u，尝试对其指向的点v进行松弛操作，如果更新成功了，并且v不在队列中，就把v入队，不断重复直到队列为空。

好像有点像bfs…

bfs是针对无权图求最短路的好方法，spfa却可以用于有权图。

这两个的作用远不止最短路…

只要可以用前一个点更新后一个点的题，好像它们都能得分…

这个题显然就是这样的辣！（我觉得和dp没什么区别）

因为是无权图，所以可以用也bfs（其实原理一样）。

如果已知前一个点的f[u]，那么就能推出后一个点f[v]=f[u]+1;

所以我们先找出初始点入队就可以了。

可是需要稍微改动一下。

因为一个点可能通过多个点到达，而这几个点的数值可能不一样。怎么办？

很显然，我们可以只用最大的点来更新。

由于bfs是通过队列实现的，所以点是按照数值从小到大的顺序处理的，所以越大的点处理地越晚。

那我们就可以只用能到达这个点中最晚被处理的点更新它就好啦。这样保证每个点被处理一次。

#include<cstdio>
#include<iostream>
#include<queue>
using namespace std;
struct edge{
int next,to;
}ed[400001];
int head[100001]={0};
int f[100001]={0};
bool vis[100001]={0};
int pre[100001]={0};
int n,m,size=0;
void read(int &x)
{
char c=getchar();x=0;
while(c<'0'||c>'9') c=getchar();
while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
}
void add(int from,int to)
{
size++;
ed[size].to=to;
ed[size].next=head[from];
head[from]=size;
}
void spfa()
{
queue <int> q;
for(int i=1;i<=n;i++)
{
if(!pre[i])
{
q.push(i);
vis[i]=1;
f[i]=1;
}
}
while(!q.empty())
{
int u=q.front();
q.pop();
for(int i=head[u];i;i=ed[i].next)
{
int v=ed[i].to;
f[v]=f[u]+1;
pre[v]--;
if(!vis[v]&&!pre[v])                 //如果再没有点能到v，说明u是最后一个能更新v的点
{
q.push(v);
vis[v]=1;
}
}
}
}
int main()
{
read(n),read(m);
for(int i=1;i<=m;i++)
{
int x,y;
read(x),read(y);
add(x,y);
pre[y]++;                               //记录能到达y点的点的数量
}
spfa();
for(int i=1;i<=n;i++)
{
printf("%d\n",f[i]);
}
return 0;
}

用spfa解非最短路问题还有noip 2009的最优贸易，那道题有环，可是没关系！转几圈不就是了。