HighWay这一题描述如下：

给定一条高速公路，

在时间点为0时公路上停了N辆车，每辆车起始位置都不同，

首先输入一个整数N，2 <= N <= 1000.

接着输入N行，每一行格式为3个整数：X, Y and L，分别是一辆车的起始位置，离开位置以及速度。 0 <= X < Y <= 1000000, 0 < L <= 10.

因为高速公路只有一条车道，所以规定行驶在后面的车子不能超过行驶在它前面的车。

链接：http://hihocoder.com/contest/hiho65/problem/1

关于这题的解法，如果把它当做追及问题，就会变得非常非常复杂，我试了一下，感觉好像不是特别难，但是在写的时候遇到各种问题，真心不简单。

所以有大神提供了一种可以用动态规划来进行解决的思路：

http://hihocoder.com/discuss/question/2533

思路

这一题的关键在于每辆车都不能超过它前面的车，所以最前面的车它可以按照自己的速度跑完，第二前的车只会受到最前面车的影响，。。。。。

由此看来，按照每辆车的起始位置进行排序是个好想法，排序之后依照顺序从最前边的车子开始依次进行处理。

这个想法是大家都能想到的，我想到这个点子之后就继续往追及问题上考虑了，我首先思考了两辆车的追及情况，overtaking是否可能，如果发生了overtaking，后边的车子有哪些需要改变的呢？反正挺复杂的，写起来非常麻烦。

幸好大神提供了另一个点子，依然是根据每辆车都不能超过它前面的车这一个限制。

它告诉了我们什么呢？在公路上的某一个地点pos上，对于一辆车car1,如果它前面还有其他的车比如car2,car3,...,

那么car1通过pos的时间一定是要大于等于car2，car3它们通过pos的时间的！

分析一下：

假设car2便是car1正前方的车，

如果car1能追上car2，并且在overtakingPos追上，那么在追上之前的这段路程car1->start到overtakingPos上car1到达的时间很明显是大于car2的，

在追上之后的路程上因为car1不能超过car2，所以它们经过这段路的时间是一样的。

如果car1不能追上car2，那么在car1的全程路段很明显它到达的时间是要大于car2的。

所以我们需要维护的是在公路上任一点pos上车子到达它所需的最大时间。

按照动态规划的方式来做的话，我的思路大致如下：

首先用类RunningCar来记录车的状态

class RunningCar
{
	double start;
	double end;
	double speed;
	double leavingTime;
        ...
};

接着为了解决问题，定义如下几个变量：

vector<int> startPoints，按照输入顺序记录各辆车起始点位置

vector<int> sortedStarts，对startPoints进行排序后的结果

map<int, RunningCar *> runningCars根据每辆车的起始点映射该辆车的结构，因为每辆车的起始位置都不同，所以正好用起始位置作为标记

int maxEnd，在输入过程中不断更新，记录所有车中最大的离开位置

double *maxArrivingTime，动态规划的核心了，我们是从sortedStarts的最后开始向前处理，记录当前已通过车辆通过pos位置的最大离开时间

代码思路大致如下：

For startPoint in sortedStarts from the rear
       curCar = runningCars[startPoint];
       For  pos from curCar.start+1 to curCar.end
             timeWithNoOvertaking = maxArrivingTime[pos-1] + 1.0/curCar.speed;
             timeWithOvertaking = maxArrivingTime[pos];
             maxArrivingTime[pos] = max( timeWithNoOvertaking,  timeWithOvertaking);
       End for       
       curCar.setLeavingTime(maxArrivingTime[curCar.end]);
End for

就上面这一小段，弄清楚了就很简单了。

在具体实现的时候，因为最近在看《代码整洁之道》，所以做了如下设计：

整个问题设计为一个HighWay类。

整段代码如下：

#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;

bool isDebug = true;

class RunningCar
{
	double start;
	double end;
	double speed;
	double leavingTime;
public:
	RunningCar()
	{
		start = end = 0;
		speed = 0;
	}
	RunningCar(double start, double end, double speed)
	{
		this->start = start;
		this->end = end;
		this->speed = speed;
	}

	double getStart()
	{
		return start;
	}
	double getEnd()
	{
		return end;
	}
	double getSpeed()
	{
		return speed;
	}
	double getLeavingTime()
	{
		return leavingTime;
	}

	void setLeavingTime(double leavingTime)
	{
		this->leavingTime = leavingTime;
	}
	void display()
	{
		cout << "I am a car starts from " << start << " ends at " << end << " with the speed of " << speed << endl;
	}
};
class HighWay
{
	int N;
	int maxEnd;
	
	map<int, RunningCar *> runningCars;
	vector<int> startPoints;
	vector<int> sortedStarts;

	double *maxArrivingTime;
public:
	HighWay()
	{
		maxEnd = 0;
		maxArrivingTime = NULL;
	}
	~HighWay()
	{
		if (maxArrivingTime != NULL)
		{
			delete[] maxArrivingTime;
			maxArrivingTime = NULL;
		}
		runningCars.clear();
		startPoints.clear();
		sortedStarts.clear();
	}
	void readDataAndInitialize()
	{
		cin >> N;
		for (int i = 0; i < N; i++)
		{
			int start, end, speed;
			cin >> start >> end >> speed;
			if (maxEnd < end)
				maxEnd = end;
			RunningCar *newCar = new RunningCar(start, end, speed);
			runningCars[start] = newCar;
			startPoints.push_back(start);
		}

		maxArrivingTime = new double[maxEnd+1];
		for (int i = 0; i < maxEnd+1; i++)
			maxArrivingTime[i] = 0;

		sortedStarts = startPoints;
		sort(sortedStarts.begin(), sortedStarts.end());

	}
	void calculateMaxLeavingTime()
	{
		int carsRunningAhead = sortedStarts.size();
		while (carsRunningAhead > 0)
		{
			RunningCar *curCar = runningCars[sortedStarts[carsRunningAhead-1]];
			calculateLeavingTimeForCar(curCar);
			carsRunningAhead--;
		}
	}

private:
	void calculateLeavingTimeForCar(RunningCar *curCar)
	{
		for (int i = curCar->getStart()+1; i <= curCar->getEnd(); i++)
		{
			calculateLeavingTimeForCarInPos(curCar, i);
		}
		curCar->setLeavingTime(maxArrivingTime[(int)curCar->getEnd()]);
		if (isDebug)
		{
			printf("The car leaved at time %.2lf\n", curCar->getLeavingTime());
		}
	}
	void calculateLeavingTimeForCarInPos(RunningCar *curCar, int pos)
	{
		double timeWithNoOvertaking = maxArrivingTime[pos-1] + 1.0/curCar->getSpeed();
		maxArrivingTime[pos] = max(maxArrivingTime[pos], timeWithNoOvertaking); 
		if (isDebug)
		{
			printf("The car starts from %.0lf, ends at %.0lf, current pos at %d, time is %.2lf\n", curCar->getStart(), curCar->getEnd(), pos, maxArrivingTime[pos]);
		}
	}
public:
	void showMaxArrivingTime()
	{
		for (int i = 0; i < maxEnd+1; i++)
		{
			cout << "The "<< i << "th max arriving time is " << maxArrivingTime[i] << endl;
		}
	}
	void showLeavingTime()
	{
		for (int i = 0; i < startPoints.size(); i++)
		{
			RunningCar *curCar = runningCars[startPoints[i]];
			//printf("%.2lf\n", maxArrivingTime[(int)curCar->getEnd()]);
			printf("%.2lf\n", curCar->getLeavingTime());
		}
	}
};
int main()
{
	
	HighWay highWay;
	highWay.readDataAndInitialize();
	highWay.calculateMaxLeavingTime();
	//highWay.calculateLeavingTimeForCar(NULL);
	if (isDebug)
		highWay.showMaxArrivingTime();
	highWay.showLeavingTime();
	system("pause");
	return 0;
}

计算某车在pos位置时的离开时间的分析：

如果在car经过pos时，

1. 它已经overtaking前面的车，因为不能超车，所以它此时前面的车速度一样，经过pos的时间也一样，所以此时时间为maxArrivingTime[pos]。

2. 如果它没有超车，那么用maxArrivingTime[pos-1]再加上跑1单位距离所需要的时间即可，

因为pos是从curCar->start+1开始的，当pos = start+1时，maxArrivingTime[pos-1]必然为0；

而当pos > start +1时，pos位置可能是前面的车已经跑的地方，所以此时有两种可能，一种是前面的车已经跑完了，所以本车恢复原速度继续跑，还有一种是pos位置只有curCar跑过，不管是哪种情况，curCar经过pos-1位置时的时间都是maxArrivingTime[pos-1]，而接着它是以curCar->speed速度跑，所以很轻易就能计算出它跑过pos的时间。

3. 最后取这两种时间的最大值即可。

void calculateLeavingTimeForCarInPos(RunningCar *curCar, int pos)
	{
		double timeWithNoOvertaking = maxArrivingTime[pos-1] + 1.0/curCar->getSpeed();
		maxArrivingTime[pos] = max(maxArrivingTime[pos], timeWithNoOvertaking); 
		if (isDebug)
		{
			printf("The car starts from %.0lf, ends at %.0lf, current pos at %d, time is %.2lf\n", curCar->getStart(), curCar->getEnd(), pos, maxArrivingTime[pos]);
		}
	}

运行中遇到的问题

1.在代码重构的时候犯了一个错误，

我定义HighWay类，它里边有个成员变量为double *maxArrivingTime，

我在构造函数里边将它初始化为NULL。

接着在void readDataAndInitialize()函数里边我是为它分配空间并进行初始化，

当时写成了double *maxArrivingTime = new double[maxEnd+1];
for (int i = 0; i < maxEnd+1; i++)
maxArrivingTime[i] = 0;

这样就出错了，同名变量的问题，C++编译的时候不会提示错误，但运行的时候却是会出错的！

2.用示例是可以运行成功，但还是得自己也设计几个例子来测试下

比如如下运行示例：

我发现出问题了，所以用isDebug进行信息输出，原来是我最后输出结果的时候出了问题

//printf("%.2lf\n", maxArrivingTime[(int)curCar->getEnd()]);
printf("%.2lf\n", curCar->getLeavingTime());

重构前的代码

看起来很乱，写完以后连看都不怎么想回头看

int main()
{
	
	vector<int> startPoints;
	map<int, RunningCar *> runningCars;
	
	int N;
	cin >> N;
	int maxEnd = 0;
	for (int i = 0; i < N; i++)
	{
		int start, end, speed;
		cin >> start >> end >> speed;
		if (maxEnd < end)
			maxEnd = end;
		RunningCar *newCar = new RunningCar(start, end, speed);
		runningCars[start] = newCar;
		startPoints.push_back(start);
	}
	double *maxArrivingTime = new double[maxEnd+1];
	for (int i = 0; i < maxEnd+1; i++)
		maxArrivingTime[i] = 0;

	vector<int> sortedStarts(startPoints);
	sort(sortedStarts.begin(), sortedStarts.end());

	int carsRunningAhead = sortedStarts.size();
	while (carsRunningAhead > 0)
	{
		RunningCar *curCar = runningCars[sortedStarts[carsRunningAhead-1]];
		for (int i = curCar->getStart(); i <= curCar->getEnd(); i++)
		{
			double curCarArrivingHereTime = 0;
			if (i >=1 && maxArrivingTime[i-1] != 0)
			{
				curCarArrivingHereTime = maxArrivingTime[i-1] + 1.0/curCar->getSpeed();
			}
			else
			{
				curCarArrivingHereTime = ((double)i-curCar->getStart())/curCar->getSpeed();  
			}
			maxArrivingTime[i] = max(maxArrivingTime[i], curCarArrivingHereTime);
		}
		curCar->setLeavingTime(maxArrivingTime[(int)curCar->getEnd()]);
		carsRunningAhead--;

	}


	for (int i = 0; i < startPoints.size(); i++)
	{
		RunningCar *curCar = runningCars[startPoints[i]];
		//cout << "The "<< i << "th car leaved at " << maxArrivingTime[(int)curCar->getEnd()] << endl;
		printf("%.2lf\n", maxArrivingTime[(int)curCar->getEnd()]);
	}

	cin >> N;
	return 0;
}

hiho一下第六十五周HighWay--也属于动态规划吧

思路

计算某车在pos位置时的离开时间的分析：

运行中遇到的问题

重构前的代码

猜你喜欢