P1137 旅行计划

P1137 旅行计划

题目描述

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

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

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

输入输出格式

输入格式：

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

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

输出格式：

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

输入输出样例

输入样例#1：

5 6
1 2
1 3
2 3
2 4
3 4
2 5

输出样例#1：

1
2
3
4
3

说明

均选择从城市1出发可以得到以上答案。

对于20%的数据，N ≤ 100；

对于60%的数据，N ≤ 1000；

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

分析：

方法一：

拓扑结构+简单dp（其实可以边拓扑边dp）

1、用栈实现拓扑结构，找出拓扑序列

2、在这个拓扑序列的基础上，找所有i节点西边的点中经过城市最多的点+1，就是i对应的答案

个人感觉verctor数组存图要比数组模拟链表存图方便很多。

#include<cstdio>  
#include<stack>  
#include<vector>  
using namespace std;  
  
int n,m,x,y,ru[100001],ans[100001];  
vector<int> ro[100001],tot;  
stack<int> q;  
  
int main()  
{  
    scanf("%d%d",&n,&m);  
    for(int i=1;i<=m;i++)  
    {  
        //读入数据 
        scanf("%d%d",&x,&y);  
        //y节点的入度加1 
        ru[y]++;  
        //相当于x多了个孩子 
        ro[x].push_back(y);  
    }  
    //下面是拓扑排序，用栈实现，其实和队列实现差不多 
    //如果入度为0，入栈，对应的答案为1 
    for(int i=1;i<=n;i++)  
      if(!ru[i]) q.push(i),ans[i]=1;  
    //当q中还有元素的时候 
    while(!q.empty())  
    {  
        //取栈最上面的元素 
        int k=q.top();q.pop();  
        tot.push_back(k);  
        //找所有连接的边 
        for(int i=0;i<ro[k].size();i++)  
        {  
            //如果入度为空，继续整入栈 
            ru[ro[k][i]]--;if(!ru[ro[k][i]]) q.push(ro[k][i]);  
        }   
    } 
    //遍历这n个点，简单dp 
    for(int i=0;i<tot.size();i++)  
    {  
        int k=tot[i];  
        //找这个点的所有入度的点 
        for(int j=0;j<ro[k].size();j++)  
        {  
            //找到这些点中节点数最大的，+1 
            int z=ro[k][j];  
            if(ans[z]<ans[k]+1) ans[z]=ans[k]+1;  
        }  
    }  
    for(int i=1;i<=n;i++) printf("%d
",ans[i]);  
    return 0;  
}  

方法二：

栈实现spfa

1、找到起点

2、从起点处做spfa，用出栈的点去更新别的所有点

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;
#define maxm 200010
int n,m,ans,num,head[maxm],dp[100010],ru[100010];
stack<int>q;
bool vis[100010];
//边 
struct node{
    int pre,to;
}e[maxm];
//数组模拟链表 
void Insert(int from,int to){
    e[++num].to=to;
    e[num].pre=head[from];
    head[from]=num;
}
void spfa(){
    //栈中还有元素 
    while(!q.empty()){
        //元素出栈 ，表示不再栈中 
        int point=q.top();q.pop();vis[point]=0;
        //遍历point的所有出度的边 
        for(int i=head[point];i;i=e[i].pre){
            int to=e[i].to;
            //用这个节点去更新所有节点 
            if(dp[to]<dp[point]+1){
                dp[to]=dp[point]+1;
                if(!vis[to]){
                    vis[to]=1;//表示在栈中 
                    //被更新的节点继续入栈 
                    q.push(to);
                }
            }
        }
    }
}
//读数 
int qread(){
    int i=0;
    char ch=getchar();
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch<='9'&&ch>='0'){i=i*10+ch-'0';ch=getchar();}
    return i;
}
int main(){
    //读数据 
    n=qread();m=qread();
    int x,y;
    for(int i=1;i<=m;i++){
        x=qread();y=qread();
        //插入x到y的边 
        Insert(x,y);
        //y的入度加1
        //入度出度这个写在读入数据这里是极好的 
        ru[y]++;
    }
    //遍历n个节点，将空节点先入栈 
    for(int i=1;i<=n;i++){
        if(ru[i]==0){
            q.push(i);
            vis[i]=1;
            //并且把值置为1 
            dp[i]=1;
        }
    }
    //做spfa 
    spfa();
    for(int i=1;i<=n;i++)printf("%d
",dp[i]);
}

方法三：

记忆化搜索

这个题只能向一边走而不能走环，所以满足无后效性原理，显然可以动态规划，一般题目显然搜索比较好(ˇˍˇ) 想；但是搜索往往会是指数级别的时间复杂度，这个题的最后几组数据显然不支持指数级别的算法，但是记忆化搜索可以满足需求，就是记忆每一次搜索的结果，可以很快速的完成搜索，而且记忆化搜索的时间复杂度和动归理论上是一样的，于是很多动归题目实在想不出来都可以记忆化搜索，有时还能减支优化。

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<vector>
#include<algorithm>
#define MAXN 400010
using namespace std;
vector<int>l[MAXN];
int n,m,u[MAXN],v[MAXN],dp[MAXN],cnt=1;
void add(int x,int y)
  {
        u[++cnt]=x;v[cnt]=y;
        //把边的编号信息加入东边的那个点 
        l[x].push_back(cnt);
  }
int dfs(int x)
 {
     int i;
     //如果搜索过x这个点，就返回 
     if(dp[x])return dp[x];
     //初始值置为1 
     dp[x]=1;
     //找所有x点的入边 
     for(i=l[x].size()-1;i>=0;i--)
       {
          int k=l[x][i];
          //所有入边中的最大值+1即为结果
          //其实是在边搜索边dp 
         dp[x]=max(dp[x],dfs(v[k])+1);    
      }
    return dp[x];
 }
int main()
  {
       int i,j,k;
       //读数据 
       scanf("%d%d",&n,&m);
       for(i=1;i<=m;i++)
         {
            int a,b;
          scanf("%d%d",&a,&b);
          //加边 
          add(b,a);    
       }
       //记忆化搜索 
     for(i=1;i<=n;i++)
           cout<<dfs(i)<<endl;
     return 0;
}

转载于:https://www.cnblogs.com/Renyi-Fan/p/7433161.html