题目
你需要访问 n 个房间,房间从 0 到 n - 1 编号。同时,每一天都有一个日期编号,从 0 开始,依天数递增。你每天都会访问一个房间。
最开始的第 0 天,你访问 0 号房间。给你一个长度为 n 且 下标从 0 开始 的数组 nextVisit 。在接下来的几天中,你访问房间的 次序 将根据下面的 规则 决定:
假设某一天,你访问 i 号房间。
如果算上本次访问,访问 i 号房间的次数为 奇数 ,那么 第二天 需要访问 nextVisit[i] 所指定的房间,其中 0 <= nextVisit[i] <= i 。
如果算上本次访问,访问 i 号房间的次数为 偶数 ,那么 第二天 需要访问 (i + 1) mod n 号房间。
请返回你访问完所有房间的第一天的日期编号。题目数据保证总是存在这样的一天。由于答案可能很大,返回对 109 + 7 取余后的结果。
示例 1:
输入:nextVisit = [0,0]
输出:2
解释:
- 第 0 天,你访问房间 0 。访问 0 号房间的总次数为 1 ,次数为奇数。
下一天你需要访问房间的编号是 nextVisit[0] = 0 - 第 1 天,你访问房间 0 。访问 0 号房间的总次数为 2 ,次数为偶数。
下一天你需要访问房间的编号是 (0 + 1) mod 2 = 1 - 第 2 天,你访问房间 1 。这是你第一次完成访问所有房间的那天。
示例 2:
输入:nextVisit = [0,0,2]
输出:6
解释:
你每天访问房间的次序是 [0,0,1,0,0,1,2,…] 。
第 6 天是你访问完所有房间的第一天。
示例 3:
输入:nextVisit = [0,1,2,0]
输出:6
解释:
你每天访问房间的次序是 [0,0,1,1,2,2,3,…] 。
第 6 天是你访问完所有房间的第一天。
思路
根据题意,要访问房间 i
,必须先恰好访问房间 i-1
两次。我们可以定义 dp[i]
为第一次访问房间 i
所需天数。那么我们有:
dp[i] = dp[i-1] + 1 (根据 nextVisit[i-1] 跳回前面房间) + (从 nextVisit[i-1] 返回 i-1 所需天数) + 1 (从 i-1 前进到 i)
又因为只有访问房间 i-1
偶数次才能前往房间 i
,当第一次访问房间 i-1
时,必然恰好访问了房间 i-2
两次。当第二次访问房间 i-1
时,必然访问房间 i-2
偶数次。由此我们可以推导出,第一次访问房间 i-1
时,房间 0 ~ i-2
的访问次数都是偶数。那么,当我们从房间 i-1
跳回到访问房间 nextVisit[i-1]
时,房间 nextVisit[i-1]
恰好被访问了奇数次,这就相当于第一次到达 nextVisit[i-1]
,然后从房间 nextVisit[i-1]
到达房间 i-1
。于是可以得到:
从 nextVisit[i-1] 返回 i-1 所需天数 = dp[i-1] - dp[nextVisit[i-1]]
综上,可以得到:
dp[i] = dp[i-1] * 2 - dp[nextVisit[i-1]] + 2
代码
// From the rule, to visit room-i for the first time, we must have visited room-i-1 exactly two times and proceed to room-i.
//
// Define dp[i] to be the # of days taken to visit room-i for the first time.
// Mark x as (# of days taken to get back to room-i-1 the second time).
// dp[i] = dp[i-1] + 1 + x + 1
//
// From the rule, we have:
// When room-i is visited for the first time, room-i-1 must be visited two times.
// When room-i-1 is being visited for the second time, room-i-2 must be visited even times.
// => the first time we visit room-i-1, # of times we have visited room 0~i-2 are even.
//
// From dp[i-1] we jump back to room nextVisit[i-1] and make its visit times odd,
// which makes it the same case as the first time to find a way from nextVisit[i-1] to room-i-1 (takes dp[i-1] - dp[nextVisit[i-1]] days).
// => x = dp[i-1] - dp[nextVisit[i-1]]
//
// To sum up, we have:
// dp[i] = dp[i-1] * 2 - dp[nextVisit[i-1]] + 2
class Solution {
public:
int firstDayBeenInAllRooms(vector<int>& nextVisit) {
constexpr int mod = 1e9+7;
vector<int64_t> dp(nextVisit.size());
dp[0] = 0;
dp[1] = 2;
for (int i = 2; i < nextVisit.size(); i++) {
dp[i] = (dp[i-1] - dp[nextVisit[i-1]] + dp[i-1] + 2 + mod) % mod;
}
return dp[nextVisit.size()-1];
}
};