1030 Travel Plan (30 point(s))

1030 Travel Plan (30 point(s))

A traveler's map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide the shortest path between his/her starting city and the destination. If such a shortest path is not unique, you are supposed to output the one with the minimum cost, which is guaranteed to be unique.

Input Specification:

Each input file contains one test case. Each case starts with a line containing 4 positive integers N, M, S, and D, where N (≤500) is the number of cities (and hence the cities are numbered from 0 to N−1); M is the number of highways; S and D are the starting and the destination cities, respectively. Then M lines follow, each provides the information of a highway, in the format:

City1 City2 Distance Cost

where the numbers are all integers no more than 500, and are separated by a space.

Output Specification:

For each test case, print in one line the cities along the shortest path from the starting point to the destination, followed by the total distance and the total cost of the path. The numbers must be separated by a space and there must be no extra space at the end of output.

Sample Input:

4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20

Sample Output:

0 2 3 3 40

思路和1087 All Roads Lead to Rome基本一致,属于PAT常见题型。考点:Dijkstra算法灵活应用。

注意点:

1. DFS回溯路径的方法,深刻理解递归。

2. 注意构造函数定义。

#include<iostream>
#include<vector>
#include<cstring>
#define MAX 0x3f3f3f3f
using namespace std;
int N,M,S,D;
const int LEN = 505;
struct Edge{
	int next;int weight;int cost;//下一个结点、距离、花销 
	Edge(int n,int w,int c):next(n),weight(w),cost(c){	}
};
vector<Edge>graph [LEN];
int dis[LEN];//记录距离 
int sumCost[LEN];//当前总花销 
int last[LEN];//记录上一个城市 
bool visit[LEN]={false};
void dfs(int x){
	if(x==S){
		cout<<x;return;
	} 
	dfs(last[x]);
	cout<<" "<<x;
}
int main(void){
	cin>>N>>M>>S>>D;
	int a,b,w,c;
	for(int i=0;i<M;i++){
		cin>>a>>b>>w>>c;
		graph[a].push_back(Edge(b,w,c));
		graph[b].push_back(Edge(a,w,c));
	}
	memset(dis,-1,sizeof(dis));
	
	int newP = S;
	visit[newP] = true;
	dis[newP] = 0;
	while(!visit[D]){
		for(int i=0;i<graph[newP].size();i++){
			int v = graph[newP][i].next;
			int w = graph[newP][i].weight;
			int c = graph[newP][i].cost;
			if(visit[v]) continue;
			if(dis[v]==-1||dis[newP]+w<dis[v]){//不可达或者有更近的路径 
				dis[v] = dis[newP]+w;//更新距离 
				sumCost[v] = sumCost[newP]+c;//更新消耗
				last[v] = newP;//更新前驱城市 
			}
			else if(dis[newP]+w==dis[v]&&sumCost[newP]+c<sumCost[v]){//距离相等但是有更小的消耗 
				sumCost[v] = sumCost[newP]+c;//更新消耗
				last[v] = newP;//更新前驱城市 				
			} 
		}
		int min = MAX;
		for(int i=0;i<N;i++){
			if(dis[i]==-1) continue;
			if(visit[i]) continue;
			if(dis[i]<min){
				min = dis[i];
				newP = i;
			}
		} 
		visit[newP] = true;
	}
	dfs(D);
	cout<<" "<<dis[D]<<" "<<sumCost[D]<<endl;
	return 0;
}

 

# Global Planner Parameters # maximum distance to the goal point goal_distance_tolerance: 0.1 # maximum allowed numerical error for goal position xy_goal_tolerance: 0.2 # maximum allowed numerical error for goal orientation yaw_goal_tolerance: 0.3 # weight for the heuristic function used in the A* algorithm # higher values prefer straighter paths, lower values prefer paths with less turning heuristic_weight: 3.0 # minimum distance to travel before attempting to replan min_replan_distance: 1.0 # minimum amount of time to wait before attempting to replan min_replan_time: 1.0 # tolerance on the robot's heading (in radians) when planning # during rotation commands this is an additional error that gets added to # yaw_goal_tolerance heading_lookahead: 0.325 # minimum lookahead to do during path planning. A shorter lookahead is more # cautious (especially in tight spaces) but may be more effective at avoiding # collisions with complex obstacles min_lookahead_distance: 0.4 # maximum lookahead to do during path planning max_lookahead_distance: 2.0 # if true, the global planner will only plan one step at a time # rather than to the final goal state intermediate_planning: false # what topic the planner should use for status feedback planner_frequency: 0.5 planner_topic: "planner_status" # how close the robot must be to the global plan before updating it with # a new one plan_update_distance: 0.5 # how often the planner should be allowed to make new plans. A value of 0 # means plans will be made as often as possible planner_patience: 5.0 # penalty for robot rotation during path planning. A higher penalty will # cause the planner to prefer straighter paths with less turns rotation_penalty: 0.8 # maximum absolute rotation speed allowed while navigating along the global # plan max_rotation_speed: 1.0 # maximum speed to travel along the global plan max_velocity: 0.6 # If true, the global planner will try to avoid obstacles with a combination # of steering and braking. Otherwise, it will only steer around obstacles braking_enabled: true # how many times to retry a goal update if the previous attempt resulted in a # collision or other error. # If set to -1, it will retry indefinitely goal_update_retries: 3 # Whether or not to use the extrinsic rotation control method in the planner use_extrinsic_rotation: true # Enabling this parameter causes the global planner to use # differential constraints for smoother trajectories use_differential_constraints: true # Enabling this parameter causes the planner to assume the # robot is driving on the right-hand side of the street drive_on_right: true # Timeout for the planning process (in seconds). If planning takes longer # than this, the planner will abort and return a failure status planning_timeout: 5.0 # If set, this parameter limits the maximum planning distance the # planner will use. Set to -1 for no limit. max_planning_distance: -1 # Enabling this parameter causes the planner to ignore the robot's ground # clearance when planning. ignore_ground_clearance: false # Whether the planner should try to avoid going backwards avoid_going_backwards: false # The maximum distance (in meters) that the planner will consider changing # the orientation of the robot to better follow the path. Set to -1 to # disable this behavior. max_orientation_change: 0.9 # The minimum distance (in meters) that the planner will consider # detecting a change in orientation of the robot to better follow the path. # Set to -1 to disable this behavior. min_orientation_change: 0.5 # Whether the planner should attempt to use the current local plan when planning. # If set to true, the planner will attempt to connect the current local plan # to the new plan. If set to false, the planner will always start from the robot's # current pose. use_local_plan: true # Whether the planner should attempt to use the current local costmap when planning. # If set to true, the planner will use the local costmap to build an estimate # of the robot's surroundings. If set to false, the planner will only use the # global costmap. use_local_costmap: true # Whether the planner should use the old behavior of setting waypoints to # the right of the global plan. This behavior causes the robot to execute # the plan with a rightward shift. However, it can be problematic if the plan # encounters obstacles on the left side. use_typical_rightward_shift: false # Whether the planner should use a zero velocity as a way to avoid oscillations. # If set to true, the planner will stop the robot and wait for the current goal # to either become unreachable or within the goal tolerance. stop_when_goal_rejected: false # The time (in seconds) that the planner will stop and wait (in case of oscillations) # before trying to replan. stop_and_wait_time: 2.0 # Distance (in meters) to be left before the end of the path. This can be useful # when the robot should stop at a certain distance from the goal pose. path_distance_offset: 0 # Maximum allowed speed deviation from the global plan (in m/s). max_allowed_speed_deviation: 1.0 # Maximum allowed angular deviation from the global plan (in rad). max_allowed_angular_deviation: 1.57 # Whether or not to use a linear navigation function to bias global plan costs toward closer parts of the map. use_linear_navigation_function: false # Whether or not to use a terrain independent cost scale to bias global plan costs toward flatter regions. use_terrain_independent_cost_scale: true # The maximum number of obstacles to check against during planning. max_obstacle_check_count: 500 # If true, the planner will skip planning during the first update cycle after initialization. skip_initial_planning: false # Scaling factor for the distances used in the Adaptive Sampling Path algorithm as_scaler: 1.0 # The maximum length of the Adaptive Sampling Path segments as_max_segment_length: 1.0 # The turning radius for the robot used in the prediction step of the Adaptive Sampling Path algorithm as_robot_radius: 0.3 # The number of areas forward used for heading smoothing in the Adaptive Sampling Path algorithm. # Set to 0 if heading smoothing is not desired. as_heading_smoothing_areas: 0 # The maximum distance the Adaptive Sampling Path algorithm will plan for. # Set to -1 for no limit. as_max_global_plan_distance: -1 # How many layers of costmaps to plan in. A higher value will allow the global # planner to take into account more layers of static and dynamic obstacles. # 0 means only use the base global costmap. planning_layers: 0
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值