DP学习——图、拓扑排序——P1137 旅行计划

题目描述

有一条横贯东西的大河，河有笔直的南北两岸，岸上各有位置各不相同的N个城市。北岸的每个城市有且仅有一个友好城市在南岸，而且不同城市的友好城市不相同。每对友好城市都向政府申请在河上开辟一条直线航道连接两个城市，但是由于河上雾太大，政府决定避免任意两条航道交叉，以避免事故。编程帮助政府做出一些批准和拒绝申请的决定，使得在保证任意两条航道不相交的情况下，被批准的申请尽量多。

输入格式

第1行，一个整数N，表示城市数。

第2行到第n+1行，每行两个整数，中间用一个空格隔开，分别表示南岸和北岸的一对友好城市的坐标。

输出格式

仅一行，输出一个整数，表示政府所能批准的最多申请数。

输入输出样例

输入 #1

7
22 4
2 6
10 3
15 12
9 8
17 17
4 2

输出 #1

4

说明/提示

50% 1<=N<=5000,0<=xi<=10000

100% 1<=N<=2e5,0<=xi<=1e6

思路

为什么要用拓扑排序？

因为该题的递推公式为dp[i] = max(dp[i], dp[j] + 1)，即在指向第i个数的有限个第j个数中，找到最大值，这要求dp[j]必须在dp[i]之前求出来，这样才能保证求dp[i]时，dp[j]为有效值，而拓扑排序：对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。 （源自百度），符合这一要求，所以使用拓扑排序。

使用邻接表储存有向图

for(int i = 1; i <= m; i++)
    {
       int u, v;
       cin >> u >> v;
       addedge(u, v);
       ru[v]++;//ru为入度
    }
void addedge(int u, int v)
{
    edge[++sum].to = v;//edge[]为边的数组
    edge[sum].next = head[u];//需要让edge[].next指向由u出发的上一条边，这样可以遍历时找到从u出发的所有边
    head[u] = sum;//将这一条边的pos存在head[u]中，若还有下一条边，重复以上过程
}

拓扑排序

//q为储存入度为0的队列，ts为储存拓扑排序结果的数组
void topsort()
{
    for(int i = 1; i <= n; i++)//初始化：将目前所有入度为0的点放进q中，并且加入到ts中（因为入度为0，接下来的边中不会再有指向他的）
        if(ru[i] == 0){
            q.push(i);
            ts[++tot] = i;
        }
    while(!q.empty())
    {
        int se = q.front();
        q.pop();
        for(int i = head[se]; i; i = edge[i].next)//遍历从该点出发的所有边
        {
            int ed = edge[i].to;
            ru[ed] --;//因为前置点已经移走，相当于已不指向后置点，所以入度减1
            if(ru[ed] == 0)
            {
                q.push(ed);//如果入度为0，放进q以及ts中
                ts[++ tot] = ed;
            }
        }
    }
}

总代码

#include<bits/stdc++.h>
using namespace std;

const int maxn=100000+15;

int n,m,sum = 0,tot = 0;
int head[maxn],ru[maxn],ts[maxn],dp[maxn];
queue<int> q;

struct EDGE
{
    int to;int next;
}edge[maxn<<2];

void addedge(int u, int v)
{
    edge[++sum].to = v;//edge[]为边的数组
    edge[sum].next = head[u];//需要让edge[].next指向由u出发的上一条边，这样可以遍历时找到从u出发的所有边
    head[u] = sum;//将这一条边的pos存在head[u]中，若还有下一条边，重复以上过程
}

//q为储存入度为0的队列，ts为储存拓扑排序结果的数组
void topsort()
{
    for(int i = 1; i <= n; i++)//初始化：将目前所有入度为0的点放进q中，并且加入到ts中（因为入度为0，接下来的边中不会再有指向他的）
        if(ru[i] == 0){
            q.push(i);
            ts[++tot] = i;
        }
    while(!q.empty())
    {
        int se = q.front();
        q.pop();
        for(int i = head[se]; i; i = edge[i].next)//遍历从该点出发的所有边
        {
            int ed = edge[i].to;
            ru[ed] --;//因为前置点已经移走，相当于已不指向后置点，所以入度减1
            if(ru[ed] == 0)
            {
                q.push(ed);//如果入度为0，放进q以及ts中
                ts[++ tot] = ed;
            }
        }
    }
}

int main()
{
    memset(ru, 0, sizeof(ru));
    memset(head, 0, sizeof(head));
    cin >> n >> m;
    for(int i = 1; i <= m; i++)
    {
        int u, v;
        cin >> u >> v;
        addedge(u, v);
        ru[v]++;//ru为入度
    }

    topsort();
//    for(int i = 1; i <= n; i++)
//        cout << ts[i] << ' ';
    for (int i = 1; i <= n;i ++) dp[i]=1;
    for (int i = 1; i <= n;i ++)
    {
        int u=ts[i];
        for (int j=head[u];j;j=edge[j].next)
        {
            int v=edge[j].to;
            dp[v]=max(dp[v],dp[u]+1);
        }
    }
    for (int i=1;i<=n;i++)
        cout << dp[i] << endl;
}