Fixing the Great Wall UVA - 1336

简单的题目，按照紫书上面的思路即可，但是在实现的过程当中又感觉到了一丝丝贪心算法的味道，嗯，有一定的违和感......

#include<iostream>
#include<vector>
#include<string>
#include<set>
#include<stack>
#include<queue>
#include<map>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<cstring>
#include<sstream>
#include<cstdio>
#include<deque>
using namespace std;

struct location{
int x, weight, dt;
};

int n, x;
double v;
vector<location> loc;
double dp[1010][1010][2];
int sum[1010];
int start;
int ans;

bool compare(const location& a, const location& b){
return a.x < b.x;
}

void solve(){
for (int i = start; i >= 0; i--){
for (int j = i; j < n; j++){
dp[i][j][0] = dp[i][j][1] = 1 << 30;
}
}
dp[start][start][0] = dp[start][start][1] = 0;
for (int i = start; i >= 0; i--){
for (int j = start; j < n; j++){
double temp_s = (i == 0 ? 0 : sum[i - 1]) + sum[n-1] - sum[j];
if (i > 0){//dp[i-1][j][0]
double temp = dp[i][j][0] + ((loc[i].x - loc[i - 1].x) / v)*temp_s+loc[i-1].weight;
dp[i - 1][j][0] = min(dp[i - 1][j][0], temp);
temp = dp[i][j][1] + ((loc[j].x - loc[i - 1].x) / v)*temp_s+loc[i-1].weight;
dp[i - 1][j][0] = min(dp[i - 1][j][0], temp);
}
if (j < n-1){//dp[i][j+1][1]
double temp = dp[i][j][1] + ((loc[j + 1].x - loc[j].x) / v)*temp_s+loc[j+1].weight;
dp[i][j + 1][1] = min(dp[i][j + 1][1], temp);
temp = dp[i][j][0] + ((loc[j + 1].x - loc[i].x) / v)*temp_s+loc[j+1].weight;
dp[i][j + 1][1] = min(dp[i][j + 1][1], temp);
}
}
}
ans = min(dp[0][n-1][0],dp[0][n-1][1]);
}

int main(){
while (cin >> n >> v >> x){
if (n == 0 && v == 0 && x == 0) break;
ans = 1 << 30;
loc.clear();
for (int i = 0; i < n; i++){
location temp;
cin >> temp.x >> temp.weight >> temp.dt;
loc.push_back(temp);
}
location t;
t.x = x, t.dt = 0, t.weight = 0;
loc.push_back(t);
sort(loc.begin(),loc.end(),compare);
n = loc.size();
for (int i = 0; i < loc.size(); i++){
if (loc[i].x==x){
start = i;
}
if (i == 0){
sum[i] = loc[i].dt;
}
else{
sum[i] = sum[i - 1] + loc[i].dt;
}
}
solve();
cout << ans << endl;
}
return 0;
}