【动态规划】P10726 [GESP202406 八级] 空间跳跃|普及+

本文涉及知识点

$GESP202406 八级$ 空间跳跃

题目描述

小杨在二维空间中有 n n n 个水平挡板，并且挡板之间彼此不重叠，其中第 i i i 个挡板处于水平高度 h i h_i hi，左右端点分别位于 l i l_i li 与 r i r_i ri。

小杨可以在挡板上左右移动，当小杨移动到右端点时，如果再向右移动会竖直掉落，从而落到下方第一个挡板上，移动到左端点时同理。小杨在挡板上每移动 1 1 1 个单位长度会耗费 1 1 1 个单位时间，掉落时每掉落 1 1 1 个单位高度也会耗费 1 1 1 个单位时间。

小杨想知道，从第 s s s 个挡板上的左端点出发到第 t t t 个挡板需要耗费的最少时间是多少？

注意：可能无法从第 s s s 个挡板到达到第 t t t 个挡板。

输入格式

第一行包含一个正整数 n n n，代表挡板数量。

第二行包含两个正整数 s , t s,t s,t，含义如题面所示。

之后 n n n 行，每行包含三个正整数 l i , r i , h i l_i,r_i,h_i li,ri,hi，代表第 i i i 个挡板的左右端点位置与高度。

输出格式

输出一个整数代表需要耗费的最少时间，如果无法到达则输出 − 1 -1 −1。

样例 #1

样例输入 #1

复制代码

样例输出 #1

复制代码

提示

样例解释

耗费时间最少的移动方案为，从第 3 3 3 个挡板左端点移动到右端点，耗费 3 3 3 个单位时间，然后向右移动掉落到第 2 2 2 个挡板上，耗费 100000 − 6 = 99994 100000-6=99994 100000−6=99994 个单位时间，之后再向右移动 1 1 1 个单位长度，耗费 1 1 1 个单位时间，最后向右移动掉落到第 1 1 1 个挡板上，耗费 3 3 3 个单位时间。共耗费 100001 100001 100001 个单位时间。

数据范围

子任务编号	数据点占比	n n n	特殊条件
1 1 1	20 % 20\% 20%	≤ 1000 \leq 1000 ≤1000	l i = 1 l_i=1 li=1
2 2 2	40 % 40\% 40%	≤ 1000 \leq 1000 ≤1000	l i = i , r i = i + 1 l_i=i,r_i=i+1 li=i,ri=i+1
3 3 3	40 % 40\% 40%	≤ 1000 \leq 1000 ≤1000

对于全部数据，保证有 1 ≤ n ≤ 1000 1\leq n\leq 1000 1≤n≤1000， 1 ≤ l i ≤ r i ≤ 10 5 1\leq l_i\leq r_i\leq 10^5 1≤li≤ri≤105， 1 ≤ h i ≤ 10 5 1\leq h_i\leq 10^5 1≤hi≤105。

动态规划

备份挡板s和t，对挡板高度从大到小排序.s = 挡板s的新下标,t=挡板t的新下标。

动态规划的状态表示

dp $i$ $j$ 记录以下状态的最小时间，到达第i块隔板的左端(j等于0，右端j等于1）。

动态规划的填报顺序

枚举前置状态 i = s to t-1 j= 0 to 1

动态规划的转移方程

每种状态都有两种后序状态：下移后到左端点下移后到右端点。第i块板子的订单在 $l i + 1 , R i + 1$ $l_{i+1},R_{i+1}$ $li+1,Ri+1$ 才有后序状态。

j = i+1 to N-1，枚举挡板。第i块挡板的左边界（右边界）在第j块挡板上，则可以掉落。只处理第一个j。

动态规划的初始值

dp $s$ $0$ =0 dp $s$ $1$ = Rs-Ls，其它全部INT_MAX/2

动态桂的返回值

如果能够掉落掉第t快板直接更新ans。

代码

核心代码

cpp 复制代码

#include <iostream>
#include <sstream>
#include <vector>
#include<map>
#include<unordered_map>
#include<set>
#include<unordered_set>
#include<string>
#include<algorithm>
#include<functional>
#include<queue>
#include <stack>
#include<iomanip>
#include<numeric>
#include <math.h>
#include <climits>
#include<assert.h>
#include<cstring>

#include <bitset>
using namespace std;

template<class T1, class T2>
std::istream& operator >> (std::istream& in, pair<T1, T2>& pr) {
	in >> pr.first >> pr.second;
	return in;
}

template<class T1, class T2, class T3 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t) ;
	return in;
}

template<class T1, class T2, class T3, class T4 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3, T4>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
	return in;
}

template<class T = int>
vector<T> Read() {
	int n;
	scanf("%d", &n);
	vector<T> ret(n);
	for(int i=0;i < n ;i++) {
		cin >> ret[i];
	}
	return ret;
}

template<class T = int>
vector<T> Read(int n) {
	vector<T> ret(n);
	for (int i = 0; i < n; i++) {
		cin >> ret[i];
	}
	return ret;
}

class Solution {
		public:
			typedef vector<tuple<int, int, int>> VT;
			int Ans(VT& lrh,int s,int t) {
				const int N = lrh.size();
				auto baks = lrh[s - 1];
				auto bakt = lrh[t - 1];
				sort(lrh.begin(), lrh.end(), [&](const auto& t1, const auto& t2) {return get<2>(t1) > get<2>(t2); });
				for (int i = 0; i < N; i++) {
					if (lrh[i] == baks) { s = i; }
					if (lrh[i] == bakt) { t = i; }					
				}
				if (s == t) { return 0; }
				vector<vector<int>> dp(N, vector<int>(2, INT_MAX / 2));
				int ans = INT_MAX / 2;
				dp[s][0] = 0; dp[s][1] = get<1>(lrh[s]) - get<0>(lrh[s]);
				for (int i = s; i < t ; i++) {
					const auto [left, r, h] = lrh[i];					
					for (int j = i + 1; j < N;j++ ) {
						const auto& [l2, r2, h2] = lrh[j];
						if ((left >= l2) && (left <= r2)) {
							dp[j][0] = min(dp[j][0],dp[i][0] + (h - h2) + (left - l2));
							dp[j][1] = min(dp[j][1],dp[i][0] + (h - h2) + (r2-left));
							if (t == j) { ans = min(ans, dp[i][0] + (h - h2)); }
							break;
						}
					}
					for (int j = i + 1; j < N; j++) {
						const auto& [l2, r2, h2] = lrh[j];
						if ((r >= l2) && (r <= r2)) {
							dp[j][0] = min(dp[j][0],dp[i][1] + (h - h2) + (r - l2));
							dp[j][1] = min(dp[j][1],dp[i][1] + (h - h2) + (r2 - r));
							if (t == j) { ans = min(ans, dp[i][1] + (h - h2)); }
							break;
						}
					}
				}			
				return (ans >= INT_MAX / 2) ? -1 : ans;
			}
		};


int main() {
#ifdef _DEBUG
	freopen("a.in", "r", stdin);
#endif // DEBUG	
	int n,s,t;
	cin >> n >> s>> t ;
	auto lrh = Read<tuple<int,int,int>>(n);
#ifdef _DEBUG
	//printf("N=%d", n);
	Out(lrh, ",lrh=");
	//Out(edge, ",edge=");
#endif // DEBUG	
	auto res = Solution().Ans(lrh,s,t);
	cout << res << endl;
	return 0;
}

单元测试