拓扑排序+dp

已于 2022-07-28 18:57:19 修改
阅读量577 收藏
点赞数
文章标签： 动态规划
于 2022-02-28 19:52:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52004482/article/details/123190488
版权

题目描述

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

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

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

输入格式

第11行为两个正整数N, MN,M。

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

输出格式

NN行，第ii行包含一个正整数，表示以第ii个城市为终点最多能游览多少个城市。

输入输出样例

输入 #1复制

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

输出 #1复制

1
2
3
4
3

说明/提示

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

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

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

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

#include<iostream>
#include<cstring>
using namespace std;
const int maxn=2e5+5;
int head[maxn<<1];
struct node{
    int to,next;
}edge[maxn<<1];
int cnt=0;
void add_edge(int from,int to)
{
    cnt++;
    edge[cnt].to=to;
    edge[cnt].next=head[from];
    head[from]=cnt;
}
int dp[maxn],top[maxn],in[maxn];
int main()
{
    int stop=0;
    int n,m;cin>>n>>m;
    memset(head,-1,sizeof(head));
    for(int i=1;i<=m;i++)
    {
        int from,to;cin>>from>>to;
        add_edge(from,to);
        in[to]++;
    }
    for(int i=1;i<=n;i++) {
        if(in[i]==0) dp[i]=1,top[++stop]=i;
    }
    for(int i=1;i<=stop;i++)
    {
        int now=top[i];
        for(int j=head[now];j!=-1;j=edge[j].next)
        {
            int to=edge[j].to;
            in[to]--;
            if(in[to]==0) top[++stop]=to;
        }
    }
    for(int i=1;i<=stop;i++)
    {
        int now=top[i];
        for(int j=head[now];j!=-1;j=edge[j].next)
        {
            int to=edge[j].to;
            dp[to]=max(dp[to],dp[now]+1);
        }
    }
    for(int i=1;i<=n;i++) cout<<dp[i]<<endl;
}

题目描述

CC国有nn个大城市和mm 条道路，每条道路连接这 nn个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这 mm 条道路中有一部分为单向通行的道路，一部分为双向通行的道路，双向通行的道路在统计条数时也计为 11条。

CC国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。

商人阿龙来到 CC 国旅游。当他得知同一种商品在不同城市的价格可能会不同这一信息之后，便决定在旅游的同时，利用商品在不同城市中的差价赚回一点旅费。设 CC 国 n 个城市的标号从 1~ n1 n，阿龙决定从 11号城市出发，并最终在 nn 号城市结束自己的旅行。在旅游的过程中，任何城市可以重复经过多次，但不要求经过所有 nn 个城市。阿龙通过这样的贸易方式赚取旅费：他会选择一个经过的城市买入他最喜欢的商品――水晶球，并在之后经过的另一个城市卖出这个水晶球，用赚取的差价当做旅费。由于阿龙主要是来 CC 国旅游，他决定这个贸易只进行最多一次，当然，在赚不到差价的情况下他就无需进行贸易。

假设 CC国有 55个大城市，城市的编号和道路连接情况如下图，单向箭头表示这条道路为单向通行，双向箭头表示这条道路为双向通行。

假设 1~n1 n 号城市的水晶球价格分别为 4,3,5,6,14,3,5,6,1。

阿龙可以选择如下一条线路：11->22->33->55，并在 22号城市以33 的价格买入水晶球，在 33号城市以55的价格卖出水晶球，赚取的旅费数为 2。

阿龙也可以选择如下一条线路11->44->55->44->55，并在第11次到达55 号城市时以 11的价格买入水晶球，在第 22 次到达44 号城市时以66 的价格卖出水晶球，赚取的旅费数为55。

现在给出 nn个城市的水晶球价格，mm 条道路的信息（每条道路所连接的两个城市的编号以及该条道路的通行情况）。请你告诉阿龙，他最多能赚取多少旅费。

输入格式

第一行包含 22 个正整数nn和 mm，中间用一个空格隔开，分别表示城市的数目和道路的数目。

第二行 n 个正整数，每两个整数之间用一个空格隔开，按标号顺序分别表示这 n 个城市的商品价格。

接下来 mm 行，每行有33个正整数x,y,zx,y,z，每两个整数之间用一个空格隔开。如果 z=1z=1，表示这条道路是城市xx到城市yy之间的单向道路；如果z=2z=2，表示这条道路为城市 xx和城市yy之间的双向道路。

输出格式

一 个整数，表示最多能赚取的旅费。如果没有进行贸易，则输出 00。

输入输出样例

输入 #1复制

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

输出 #1复制

5

说明/提示

【数据范围】

输入数据保证 11 号城市可以到达nn号城市。

对于 10%的数据，1≤n≤61≤n≤6。

对于 30%的数据，1≤n≤1001≤n≤100。

对于 50%的数据，不存在一条旅游路线，可以从一个城市出发，再回到这个城市。

对于 100%的数据，1≤n≤1000001≤n≤100000，1≤m≤5000001≤m≤500000，1≤x1≤x，y≤ny≤n，1≤z≤21≤z≤2，1≤1≤各城市

水晶球价格≤100≤100。

NOIP 2009 提高组 第三题

#include<iostream>
#include<cstring>
using namespace std;
//#define int long long
const int maxn=5e5+5;
int n,m;
int head1[maxn<<1],head2[maxn<<1];
int low[maxn],dfn[maxn],st[maxn],id,instack[maxn],belong[maxn],dp[maxn],mx[maxn],mn[maxn],mc[maxn],top[maxn],in[maxn];
int val[maxn];
struct node{
    int to,next;
}edge1[maxn<<1],edge2[maxn<<1];
int cnt1,cnt2;
void init()
{
    memset(head1,-1,sizeof(head1));
    memset(head2,-1,sizeof(head2));
    memset(dfn,-1,sizeof(dfn));
}
void add_edge1(int from,int to)
{
    cnt1++;
    edge1[cnt1].to=to;
    edge1[cnt1].next=head1[from];
    head1[from]=cnt1;
}
void add_edge2(int from,int to)
{
    cnt2++;
    edge2[cnt2].to=to;
    edge2[cnt2].next=head2[from];
    head2[from]=cnt2;
}
int num,cnt;
void dfs(int root)
{
    low[root]=dfn[root]=++id;
    st[++num]=root;
    instack[root]=1;
    for(int i=head1[root];i!=-1;i=edge1[i].next)
    {
        int now=edge1[i].to;
        if(dfn[now]==-1)
        {
            dfs(now);
            low[root]=min(low[root],low[now]);
        }
        else if(instack[now]) low[root]=min(low[root],dfn[now]);
    }
    if(low[root]==dfn[root])
    {
        cnt++;
        int Mx=0,Mn=105;
        while(st[num]!=root)
        {
            belong[st[num]]=cnt;
            instack[st[num]]=0;
            Mx=max(Mx,val[st[num]]);
            Mn=min(Mn,val[st[num]]);
            num--;
        }
        instack[st[num]]=0;
        belong[st[num]]=cnt;
        Mx=max(Mx,val[st[num]]);
        Mn=min(Mn,val[st[num]]);
        num--;
        mx[cnt]=Mx,mn[cnt]=Mn;
    }
}
void trajan()
{
    for(int i=1;i<=n;i++) if(dfn[i]==-1) dfs(i);
    for(int i=1;i<=n;i++)
    {
        for(int j=head1[i];j!=-1;j=edge1[j].next)
        {
            int to=edge1[j].to;
            if(belong[i]!=belong[to]) {
                add_edge2(belong[i],belong[to]);
            }
        }
    }
    for(int i=1;i<=cnt;i++)
    {
        for(int j=head2[i];j!=-1;j=edge2[j].next)
        {
            int to=edge2[j].to; in[to]++;
        }
    }
    int stop=0;
    for(int i=1;i<=cnt;i++) {
        if(in[i]==0) top[++stop]=i;
    }
    for(int i=1;i<=stop;i++)
    {
        for(int j=head2[top[i]];j!=-1;j=edge2[j].next)
        {
            int to=edge2[j].to;
            in[to]--;
            if(in[to]==0) top[++stop]=to;
        }
    }
    mc[top[1]]=mn[top[1]];
    for(int i=1;i<=stop;i++)
    {
        int now=top[i];
        for(int j=head2[now];j!=-1;j=edge2[j].next)
        {
            int to=edge2[j].to;
            mc[to]=min(mc[now],mn[to]);
            dp[to]=max(max(dp[to],dp[now]),max(mx[to]-mc[to],mx[to]-mn[to]));
        }
    }
    cout<<dp[belong[n]];
}
int main()
{
    init();
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>val[i];
    for(int i=1;i<=m;i++)
    {
        int from,to;cin>>from>>to;
        int op;cin>>op;
        add_edge1(from,to);
        if(op==2) add_edge1(to,from);
    }
    trajan();
    return 0;
} 

Link hates running.

Today, Link is asked to run. Roads in BIT can be described as nn nodes and mm directed edges. Link has to run from node 11 to node nn. When Link is at node u_iui​, he can run through the ii-th edge to get to node v_ivi​. Every time he runs through the ii-th edge, he spends e_iei​ points of energy and gains p_ipi​ points of physical fitness.

As a lazy boy, Link wants to spend as little energy as possible. He is also greedy and wants to gain maximum physical fitness when spending minimum energy.

Tell Link the minimum energy min_emine​ he needs to spend and the maximum physical fitness max_pmaxp​ he can gain when spending the minimum energy.

Input

Each test contains multiple test cases. The first line contains the number of test cases T(1 \le T \le 12)T(1≤T≤12). Description of the test cases follows.

The first line contains two integers n,m(2 \leq n \leq 10^5, 1 \leq m \leq 3 \times 10^5)n,m(2≤n≤105,1≤m≤3×105), which are the number of nodes and the number of edges.

Each of the next mm lines contains four integers u_i,v_i,e_i,p_i(1 \leq u_i,v_i \leq n, 0 \leq e_i,p_i \leq 10^9ui​,vi​,ei​,pi​(1≤ui​,vi​≤n,0≤ei​,pi​≤109), describing an edge.

Output

For each test case, output min_emine​ and max_pmaxp​ in a single line, separated by one space.

It is guaranteed that THE ANSWER EXISTS and CAN BE REPRESENTED AS A NUMBER.

#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
typedef pair<ll,int> PII;
const int N=1e5+5,M=6e5+5;
const ll INF=1e18;
vector<int> v[N];
int h[N],e[M],ne[M],w[M],p[M],idx,h2[N];
int n,m;
struct node{
	int x,y,z,d;
}edge[M];
void add(int h[],int a,int b,int c,int d)
{
	e[idx]=b,w[idx]=c,p[idx]=d,ne[idx]=h[a],h[a]=idx++;
}
int st[N],instack[N],dfn[N],low[N],belong[N],top,scc_cnt,id;
void tarjan(int root)
{
	low[root]=dfn[root]=++id;
	instack[root]=1;
	st[++top]=root;
	for(int i=h[root];~i;i=ne[i])
	{
		int to=e[i];
		if(!dfn[to])
		{
			tarjan(to);
			low[root]=min(low[to],low[root]);
		}
		else if(instack[to]) low[root]=min(low[root],dfn[to]);
	}
	if(dfn[root]==low[root])
	{
		int y;
		scc_cnt++;
		do{
			y=st[top--];
			v[scc_cnt].push_back(y);
			belong[y]=scc_cnt;
			instack[root]=0;
		}while(y!=root);
	}
}
int du[N],qu[N];
ll dp[N],g[N];
int vis[N];
void djk()
{
	dp[1]=0;
	priority_queue<PII,vector<PII>,greater<PII> > q;
	q.push({0,1});
	while(!q.empty())
	{
		PII now=q.top();q.pop();
		int v=now.second;
		if(vis[v]) continue;
		vis[v]=1;
		for(int i=h[v];~i;i=ne[i])
		{
			int to=e[i];
			if(dp[to]>dp[v]+w[i]) 
			{
				dp[to]=dp[v]+w[i];
				q.push({dp[to],to});
			}
		}
	}
}
void topsort(int h[])
{
	int hh=0,tt=-1;
	for(int i=1;i<=n;i++)
	{
		if(belong[1]==belong[i]) qu[++tt]=i;
	}
	while(hh<=tt)
	{
		int t=qu[hh++];
		for(int i=h[t];~i;i=ne[i])
		{
			int to=e[i];
			if(belong[to]==belong[t]) continue;
			g[belong[to]]=max(g[belong[t]]+p[i],g[belong[to]]);
			du[belong[to]]--;
			if(du[belong[to]]==0) 
			{
				for(int j=0;j<v[belong[to]].size();j++)
				{
					qu[++tt]=v[belong[to]][j];
				}
			}
		}
	}
}
void solve()
{
	scanf("%d%d",&n,&m);
	for(int i=0;i<=n;i++) 
	{
		dp[i]=INF,g[i]=0;
		h[i]=-1;dfn[i]=0;
		h2[i]=-1;du[i]=0;
		vis[i]=0;instack[i]=0;
		v[i].clear();
	}
	scc_cnt=top=id=idx=0;
	for(int i=1;i<=m;i++)
	{
		int a,b,c,d;
		scanf("%d%d%d%d",&a,&b,&c,&d);
		edge[i]={a,b,c,d};
		add(h,a,b,c,d);
	}
	djk();
	for(int i=1;i<=m;i++)
	{
		int a=edge[i].x,b=edge[i].y,c=edge[i].z,d=edge[i].d;
		if(dp[b]==dp[a]+c)
		add(h2,a,b,c,d),du[b]++;
	}
	for(int i=1;i<=n;i++)
	{
		if(!dfn[i]) tarjan(i);
	}
	topsort(h2);
	printf("%lld %lld\n",dp[n],g[belong[n]]);
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		solve();
	}
 }

woacioawdo
关注
拓扑排序 + DP
Sti1lWater的博客
03-25 182
拓扑DP
341. 最优贸易(spfa最短路+动态规划+反向图)
m0_46656833的博客
04-24 567
C 国有 n 个大城市和 m 条道路，每条道路连接这 n 个城市中的某两个城市。 任意两个城市之间最多只有一条道路直接相连。 这 m 条道路中有一部分为单向通行的道路，一部分为双向通行的道路，双向通行的道路在统计条数时也计为 1 条。 C 国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。 但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。 商人阿龙来到 C 国旅游。 当他得知“同一种商品在不同城市的价格可能会不同”这一信息之后，便决定在旅游的同时，利用商品在
NOIP2009 最优贸易
weixin_30372371的博客
03-28 194
最优贸易 题目描述Description C 国有 n 个大城市和 m 条道路，每条道路连接这 n 个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这 m 条道路中有一部分为单向通行的道路，一部分为双向通行的道路，双向通行的道路在统计条数时也计为 1 条。C 国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。但是，同...
P1073 最优贸易（缩点+spfa）
whisperlzw的博客
03-21 371
题目描述 CC国有nn个大城市和mm条道路，每条道路连接这nn个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这mm条道路中有一部分为单向通行的道路，一部分为双向通行的道路，双向通行的道路在统计条数时也计为11条。 CC国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。 ...
luoguP1073 最优贸易
Coco_T的博客
08-07 782
题目描述C 国有 n 个大城市和 m 条道路，每条道路连接这 n 个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这 m 条道路中有一部分为单向通行的道路，一部分为双向通行的道路，双向通行的道路在统计条数时也计为 1 条。C 国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。商人阿龙来到
Codeforces 721 C. Journey（拓扑排序+DP）
01-03
因为是有向无环图，所以我们可以在拓扑排序的时候进行dp，循环n个点，复杂度On^2，然后多开一个pre[i][j]记录经过i点时的前一个点。 由于开了两个5000*5000的数组，所以得用int，如果用long long会MLE。 代码如下： ...
【Atcoder Dp G Longest Path】拓扑排序 + dp
我是谁 --- 卡比兽
04-18 570
Atc G 这题拿来自己很蠢 先是统计所有点的入度 然后按入度排序 然后跑1500次 简单dp 但是WA了大概7/22个点 太久没写拓扑了(拓扑不经常用 这题其实就是按照DAG拓扑 已经给你了dp转移的顺序 然后我们在拓扑排序的基础上进行dp转移 /* if you can't see the repay Why not just work step by step rub...
leetcode 1857 拓扑排序+dp
qq_39678022的博客
06-17 283
问题如上图所示，求每条路径的最大节点数目求max。 做法是拓扑排序+dp。每个节点用上一个节点存的各个节点的数量进行更新，这个是核心。 class Solution { map<int, vector<int>> adj; public: int largestPathValue(string colors, vector<vector<int>>& edges) { int n = colors.size(); .
食物链（拓扑排序+dp）
qq_61037155的博客
02-22 504
题目链接：专题训练3-图论 - Virtual Judge (vjudge.net) 题目：现在给你nn个物种和mm条能量流动关系，求其中的食物链条数。 物种的名称为从11到nn的编号。 mm条能量流动关系形如 a_1a1​b_1b1​ a_2a2​b_2b2​ a_3a3​b_3b3​ … … a_mam​b_mbm​ 其中a_i \ b_iai​bi​表示能量从物种a_iai​流向物种b_ibi​。注意单独的一种孤立生物不算一条食物链。 输入格式 第一...
POJ 3249 Test for Job DAG图上的单源最短路径
代码改变世界，keep coding。
10-24 1183
点击打开链接 Test for Job Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 8584   Accepted: 1908 Description Mr.Dog was fired by his company. In order to
拓扑排序+dp 旅行计划
小蒟蒻wddwjlss的博客
08-31 377
题意：给出一张图，对于给出每一组边的关系(x,y)(x,y)(x,y)，x在yx在yx在y的西边。可以从图上的任意一个点出发，但每次只能往东走，求以1−n1−n1-n为终点的话最多可以走多少个点。 首先，我们发现这是一张横向有向图，前面的结果会影响后面的结果，所以考虑拓扑排序。这里设f[i]f[i]f[i]表示以iii为终点的话最多可以走多少个点。f[i]f[i]f[i]的初值均为111，在进行...
拓扑排序+DP—— CodeForces - 919D Substring
weixin_44064434的博客
08-02 494
拓扑排序 在图论中，拓扑排序（TopologicalSorting）是一个有向无环图（DAG,DirectedAcyclicGraph）的所有 顶点的线性序列。且该序列必须满足下面两个条件： 1.每个顶点出现且只出现一次。 2.若存在一条从顶点A到顶点B的路径，那么在序列中顶点A出现在顶点B的前面。 拓扑排序通常用来“排序”具有依赖关系的任务。 比如，如果用一个DAG图来表示一个工程，...
最优贸易
StaroForgin的博客
10-21 208
最优贸易 题解 笔者最开始想的缩点，只是一直没对。本题可以用搜索依次更新每一个节点的值。记录下当前最低的价格与最大的差价。如果两个值都未更新即可退出。否则，就开始与其连接的几个点的搜索。 源码 ​#include<cstdio> #include<cmath> #include<cstring> #include<iostream> #...
最优贸易-------------最优贸易
qq_45772483的博客
04-01 134
C国有 n 个大城市和 m 条道路，每条道路连接这 n 个城市中的某两个城市。 任意两个城市之间最多只有一条道路直接相连。 这 m 条道路中有一部分为单向通行的道路，一部分为双向通行的道路，双向通行的道路在统计条数时也计为1条。 C国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。 但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。 商人阿龙来到C国旅...
POJ 3249 拓扑排序+ 简单DP
java开发指南博客 【转载】
07-01 338
为啥要给这个水题写个解题报告呢 因为这个题太坑人了。 非常简单的题意，但是数据量超级大 我首先用了DFS，毫无疑问超时了 然后又BFS，居然又超时了 然后加上超级源点超级汇点后SPFA，各种WA后继续超时 最后逼急了去写拓扑排序，瞬间就过了。 加了读入优化后能排进第一版了。 其实刚开始就准备写拓扑了，但是为了试验算法，TLE和WA了好长时间， #include &lt;io...
图论算法解析：克隆图与拓扑排序
"图论在IT领域中的应用，包括克隆图和拓扑排序的问题解析" 在计算机科学中，图论是一门重要的理论基础，它在数据结构和算法设计中扮演着核心角色。本文将深入探讨两个与图论相关的知识点：克隆图和拓扑排序，这些都...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值