过路费[codevs 1519]

14 篇文章 0 订阅
1 篇文章 0 订阅

AC通道:http://codevs.cn/problem/1519/

[分析]

看到这道题,大家有没有想到一道原题呢?反正我是想到了——NOIP2013货车运输。

一模一样的原题啊,只是最大值变为了最小值,而且还不需要判断是否连通。

只需要先求出原图的最小生成树,然后用倍增法就可以轻松解决本题。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

struct Node{
	int nxt,data,weight;
};

struct Edge{
	int l,r,weight;
};

int n,m,cnt=1,q;
Node node[200010];
int head[10010];
int fa[10010];
int rfa[10010][15];
int rmq[10010][15];
int deep[10010];
Edge input[100010];
bool vis[10010];

bool cmp(Edge a,Edge b){
	return a.weight<b.weight;
}

inline int Max(int x,int y){
	return x>y?x:y;	
}

void add(int x,int y,int z){
	node[cnt].nxt=head[x];node[cnt].data=y;node[cnt].weight=z;head[x]=cnt++;
	node[cnt].nxt=head[y];node[cnt].data=x;node[cnt].weight=z;head[y]=cnt++;
}

int find(int x){
	int tmp=x,pre;
	while(tmp!=fa[tmp])tmp=fa[tmp];
	while(x!=tmp){
		pre=fa[x];
		fa[x]=tmp;
		x=pre;
	}
	return tmp;
}

void merge(int x,int y){
	int fx=find(x),fy=find(y);
	fa[fx]=fy;
}

void kruskal(){
	sort(input+1,input+m+1,cmp);
	int counts=0,i=0;
	while(counts<n-1){
		i++;
		if(find(input[i].l)!=find(input[i].r)){
			counts++;
//			printf("%d ,%d ,%d\n",input[i].l,input[i].r,input[i].weight);
			merge(input[i].l,input[i].r);
			add(input[i].l,input[i].r,input[i].weight); 
		}
	}
}

void dfs(int now,int rrfa,int ju){
//	printf("%d %d %d\n",now,head[now],node[head[now]].data);
	if(rrfa!=-1)deep[now]=deep[rrfa]+1;
	else deep[now]=1;
	rfa[now][0]=rrfa;
	rmq[now][0]=ju;
	for(int i=1;i<=14;i++){
		if(rfa[now][i-1]==-1)break;
		rfa[now][i]=rfa[rfa[now][i-1]][i-1]; 
		rmq[now][i]=Max(rmq[rfa[now][i-1]][i-1],rmq[now][i-1]);
	}
	for(int i=head[now];i;i=node[i].nxt)
	if(!vis[node[i].data]){
		vis[node[i].data]=true;
		dfs(node[i].data,now,node[i].weight);
	}
}

int lca(int x,int y){
	if(x==y)return 0;
	int ans=-1;
	if(deep[x]<deep[y]){int t=x;x=y;y=t;}
	if(deep[x]>deep[y]){
		int derta=deep[x]-deep[y];
		for(int i=0;i<=14;i++)
			if((1<<i)&derta){
				ans=Max(ans,rmq[x][i]);
				x=rfa[x][i];
			}
	}
	if(x==y)return ans;
	for(int i=14;i>=0;i--){
		if(rfa[x][i]!=-1&&rfa[y][i]!=-1&&rfa[x][i]!=rfa[y][i]){
			ans=Max(ans,rmq[x][i]);ans=Max(ans,rmq[y][i]);
			x=rfa[x][i];y=rfa[y][i];
		}
	}
	ans=Max(ans,rmq[x][0]);ans=Max(ans,rmq[y][0]);
	return ans; 
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)fa[i]=i;
	for(int i=1;i<=m;i++)scanf("%d%d%d",&input[i].l,&input[i].r,&input[i].weight);
	kruskal();
	memset(rfa,-1,sizeof rfa);
	memset(rmq,-1,sizeof rmq);
	memset(deep,-1,sizeof deep);
	vis[1]=true;
	dfs(1,-1,-1);
/*	for(int i=1;i<=n;i++){
		for(int j=0;j<=14;j++)
			if(rfa[i][j]!=-1){
				printf("(%d,%d) ",rfa[i][j],rmq[i][j]);
			}
		printf("\n");
	}*/
	scanf("%d",&q);
	for(int i=1;i<=q;i++){
		int x,y;
		scanf("%d%d",&x,&y);
//		if(find(x)!=find(y))printf("-1\n");
		printf("%d\n",lca(x,y));
	}
	return 0;
}


  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
这是一个典型的最大路径问题,可以使用拓扑排序和动态规划来解决。具体来说,我们可以先对给定的图进行拓扑排序,然后按照拓扑序列的逆序进行动态规划,计算出每个城市到城市 n 的最大补给值。最终,我们只需要查找城市 1 到城市 n 的最大补给值,并将其减去城市 1 到城市 n 的最小过路费即可。 下面是一个用 C++ 实现的解决方案: ```cpp #include <iostream> #include <vector> #include <queue> #include <cstring> using namespace std; const int MAXN = 1000005; const int INF = 0x3f3f3f3f; struct Edge { int v, t, x; }; vector<Edge> edges[MAXN]; int in_degree[MAXN]; int dp[MAXN]; bool vis[MAXN]; void add_edge(int u, int v, int t, int x) { edges[u].push_back({v, t, x}); in_degree[v]++; } void topo_sort(int n) { queue<int> q; memset(dp, -1, sizeof(dp)); dp[n] = 0; q.push(n); while (!q.empty()) { int u = q.front(); q.pop(); vis[u] = true; for (auto e : edges[u]) { int v = e.v, t = e.t, x = e.x; if (t == 1) { dp[v] = max(dp[v], dp[u] - x); } else { dp[v] = max(dp[v], dp[u] + x); } in_degree[v]--; if (in_degree[v] == 0) { q.push(v); } } } } int main() { int n, m; cin >> n >> m; while (m--) { int u, v, t, x; cin >> u >> v >> t >> x; add_edge(u, v, t, x); } topo_sort(n); if (!vis[1]) { cout << "NULL" << endl; } else { int ans = dp[1]; for (int i = 2; i <= n; i++) { if (!vis[i]) { continue; } for (auto e : edges[i]) { int v = e.v, t = e.t, x = e.x; if (t == 1) { ans = max(ans, dp[i] - dp[v] - x); } } } cout << ans << endl; } return 0; } ``` 其中,`n` 表示城市的数量,`m` 表示公路的数量。我们使用一个 `vector` 数组 `edges` 来存储图的信息,其中 `edges[u]` 表示以城市 `u` 为起点的所有边。同时,我们使用一个 `in_degree` 数组来记录每个城市的入度,以便进行拓扑排序。我们还使用一个 `dp` 数组来记录每个城市到城市 n 的最大补给值。最后,我们使用一个 `vis` 数组来记录每个城市是否被访问过。 在程序中,我们首先读入公路信息,并根据公路类型和费用建立有向边。接着,我们进行拓扑排序,按照拓扑序列的逆序进行动态规划,计算出每个城市到城市 n 的最大补给值。最后,我们遍历每个城市的出边,计算出城市 1 到城市 n 的最小过路费,并将其减去城市 1 到城市 n 的最大补给值即可得到最终结果。 希望这个算法能够帮助到您!

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值