【LeetCode动态规划#17】知道秘密的人，维护多个dp数组

知道秘密的人数

在第 1 天，有一个人发现了一个秘密。

给你一个整数 delay ，表示每个人会在发现秘密后的 delay 天之后，每天 给一个新的人 分享 秘密。同时给你一个整数 forget ，表示每个人在发现秘密 forget 天之后会 忘记 这个秘密。一个人 不能 在忘记秘密那一天及之后的日子里分享秘密。

给你一个整数 n ，请你返回在第 n 天结束时，知道秘密的人数。由于答案可能会很大，请你将结果对 109 + 7 取余 后返回。

示例 1：

输入：n = 6, delay = 2, forget = 4
输出：5
解释：
第 1 天：假设第一个人叫 A 。（一个人知道秘密）
第 2 天：A 是唯一一个知道秘密的人。（一个人知道秘密）
第 3 天：A 把秘密分享给 B 。（两个人知道秘密）
第 4 天：A 把秘密分享给一个新的人 C 。（三个人知道秘密）
第 5 天：A 忘记了秘密，B 把秘密分享给一个新的人 D 。（三个人知道秘密）
第 6 天：B 把秘密分享给 E，C 把秘密分享给 F 。（五个人知道秘密）

示例 2：

输入：n = 4, delay = 1, forget = 3
输出：6
解释：
第 1 天：第一个知道秘密的人为 A 。（一个人知道秘密）
第 2 天：A 把秘密分享给 B 。（两个人知道秘密）
第 3 天：A 和 B 把秘密分享给 2 个新的人 C 和 D 。（四个人知道秘密）
第 4 天：A 忘记了秘密，B、C、D 分别分享给 3 个新的人。（六个人知道秘密）

提示：

2 <= n <= 1000
1 <= delay < forget <= n

思路

简单来说就是将当前的人分为三类：知道秘密的人、遗忘秘密的人、正在分享秘密的人

然后使用者三类人进行互推与计算。

知道秘密的人可能会与正在分享秘密的人有重合

例如：A在第一天知道了秘密，假设延迟天数delay为3，那么他在第3天可以分享秘密，如果第3天A把秘密分享给了B，那么现在知道秘密的人就有2个，但是正在分享秘密的人还是只有A一个，因为B还没到延迟天数

代码

在实现上，我们需要维护3个dp数组，具体如下:

class Solution {
public:
    int peopleAwareOfSecret(int n, int delay, int forget) {
        long long mod = 1000000007;
        vector<int> dpKnow(n + 1, 0);//第i天知道秘密的人（还不能分享，因为还没到delay天，可以分享后会转变为dpShare）
        vector<int> dpForget(n + 1, 0);//第i天忘了秘密的人
        vector<int> dpShare(n + 1, 0);//第i天可以分享秘密的人（注意，这部分人与知道秘密的人是有重合的）

        //初始化分为两部分：初始化第一天时三个数组的值、根据第一天的值计算出后面天数中可以确定的值
        //第1天的时候，知道秘密的人1个
        //第1天的时候，将要忘记秘密的人0个
        //第1天的时候，可以分享秘密的人0个
        dpKnow[1] = 1;//后两个就不用填了
        
        //然后我们依据dpKnow在第一天的情况，计算出dpForget和dpShare在后续天数中的值
        //那么这个人在forget天之后会忘掉秘密，因此我们可以求出1 + forget天时dpForget的情况
        if(1 + forget <= n){//假设第一个人是A，那么A会在1 + forget天时忘掉秘密，此时忘掉秘密的人只有他一个
            dpForget[1 + forget] = 1;
        }
        //第一个知道秘密的人肯定是要到1 + delay天之后才可以分享，因此dpShare在1 + deelay天时的值为1
        if(1 + delay <= n){
            dpShare[1 + delay] = 1;
        }

        //第二天之后！
        for(int i = 2; i <= n; ++i){
            //我们也还是先看第i天有几个人知道秘密，根据dpKnow的含义可得计算方法如下：
            //dpKnow[i] = dpKnow[i - 1] - dpForget[i] + dpShare[i]
            //即：第i天知道秘密的人 = 第i - 1天知道秘密的人 - 第i天忘掉秘密的人 + 第i天被分享了秘密的人
            dpKnow[i] = (mod + dpKnow[i - 1] - dpForget[i] + dpShare[i]) % mod;

            //然后计算之后会忘记的人，可以参考初始化时的计算方式：第一天有1个人，那么这个人在1 + forget天会忘掉
            //同理，第i天新增了多少知道秘密的人，那么这些人在i + forget天后就会忘掉秘密
            if(i + forget <= n){//i + forget天前知道秘密的早忘了，i + forget之后知道的肯定不会忘
                dpForget[i + forget] = dpShare[i];
            }

            //最后计算第i天新增了多少可以分享秘密的人
            //来到第i天时，可以分享秘密的人是:第i天熬过了delay天的新增加的知道秘密的人和之前可以分享秘密的人（并且这些人到第i天还没忘）
            //举个例子：
            //第7天，当前有一堆可以分享秘密的人.他们中有一些可能是第6天满足delay期限后变成可以分享的，也有一些可能已经分享了几天并且快忘了的
            //然后第7天还会产生一堆被分享后知道秘密的新人，这些新人现在还不能分享秘密
            //那么等到了7 + delay天，此时在第7天产生的新人就都可以分享秘密了，并且还留有一部分第7天已经在分享秘密并且7 + delay天还没忘的人
            //这两部分人共同构成了7 + delay天可以分享秘密的人的人员构成，也就是dpShare[7 + delay]
            if(i + delay <= n){
                dpShare[i + delay] = (mod + dpShare[i + delay - 1] - dpForget[i + delay] + dpShare[i]) % mod;
                //dpShare[i]是在第i天新增的人，这些人在i + delay天时可以分享秘密
                //dpShare[i + delay - 1] - dpForget[i + delay]是之前能够分享秘密的人，但这些人到了i + delay天要忘掉一批人（即减掉i + delay当天的遗忘人数dpForget[i + delay]）
            }  
        }
        return dpKnow[n];
    }
};