1997. 访问完所有房间的第一天

题目

你需要访问 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];
    }
};