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];
    }
};

你可能感兴趣的:(leetcode刷题,#,动态规划,leetcode,算法,动态规划)