718.Maximum Length of Repeated Subarray(M)

最新推荐文章于 2022-07-18 14:31:22 发布

原创最新推荐文章于 2022-07-18 14:31:22 发布 · 986 阅读

0 ·

CC 4.0 BY-SA版权

动态规划专栏收录该内容

11 篇文章

订阅专栏

本文通过对比暴力求解和动态规划两种方法，介绍了如何解决两个数组间的最长重复子集问题。通过对原始暴力方法的分析，指出其存在的重复计算问题，并提出使用动态规划来优化效率。

题目描述

给定两个数组A，B，要求两个数组中最长重复的子集，原题以及例子如下，
这里写图片描述
看到题目表述后，很容易想到一种方法，暴力求解，下面附上我暴力求解的代码

int findLength(vector<int>& A, vector<int>& B) {
        int max = 0;
        int count = 0;
        int j = 0;
        int lengthA = A.size();
        int lengthB = B.size();
        for (int i = 0; i < lengthA; ++i) {
            count = 0;
            j = 0;
            if (lengthA - i <= max) break;
            while (j != lengthB) {
                if (i + count < lengthA && j + count < lengthB && A[i + count] == B[j + count]) {
                    ++count;
                } else {
                    if (max < count) {
                        max = count;
                    }
                    count = 0;
                    ++j;
                }
            }
        }
        return max;
    }

写完后，细心的同学能发现，这里是有很多重复的子问题的。那么，如果有重复的子问题我们应该用什么方法消除重复的计算呢？很明显，是动态规划。
首先，我们确定重复计算出现的地方。在这道题里是很明显的，在里层的while循环里做了很多不必要的循环。即，当匹配到某个数字相同时，会从当前位置继续比较A的下一个字符串，但其实这个动作在下一次循环中会重复。
然后，想一想怎么在空间和时间上作一个权衡，即减少重复计算，把之前的计算存储起来。在这道题里，我们可以发现，当A[i] = B[i]时，我们原本是对count做一个加法运算，我们在此时可以把count存储起来，那么之后就没必要继续进行重复的计算，让A[i]的下一个字母与B[i]的下一个字母继续比较，可以在下一次的循环中直接查询。之后再进行计算时，直接索引到这个位置然后加一就好。
下面是我动态规划代码的实现，

int findL(vector<int>& A, vector<int>& B) {
        int max = 0;
        int la = A.size();
        int lb = B.size();
        vector<vector<int> > dp( la + 1, vector<int>( lb + 1, 0 ) );

        for (int i = 1; i <= la; ++i) {
            for (int j = 1; j <= lb; ++j) {
                if (A[i - 1] == B[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    max = dp[i][j] > max ? dp[i][j] : max;
                }
            }
        }
        return max;

    }