记忆化搜索

记忆化搜索

斐波那契数

题目：斐波那契数

思路

递归 时间复杂度O(2^n)

C++代码

class Solution 
{
public:
    int fib(int n) 
    {
        if(n == 0 || n == 1) return n;
        
        return fib(n - 1) + fib(n - 2);
    }
};

优化

使用记忆化搜索（大剪支）

• 添加一个“备忘录” <可变参数，返回值>
• 递归每次返回时，将结果放在“备忘录”中
• 下次要用的时候，直接去“备忘录”中看

将已经计算的值存起来 就是记忆化搜索和动态规划的本质；

// 记忆化搜索
int memo[31];
class Solution 
{
public:
    int fib(int n) 
    {
        // 初始化
        memset(memo, -1, sizeof memo);
        return dfs(n);
    }
    int dfs(int n)
    {
        // 之前计算了，直接返回
        if(memo[n] != -1) return memo[n];

        if(n == 0 || n == 1)
        {
            memo[n] = n;
            return n;
        }

        memo[n] = dfs(n - 1) + dfs(n - 2);
        return memo[n];
    }
};




// 动态规划
class Solution 
{
    int dp[31];
public:
    int fib(int n) 
    {
        dp[0] = 0, dp[1] = 1;
        for (int i = 2; i <= n; i++)
            dp[i] = dp[i - 1] + dp[i - 2];
            
        return dp[n];
    }
};

记忆化搜索和动态规划的比较

不同路径

题目：不同路径

思路

递归

优化

正常递归时间复杂度太高，借助一个“备忘录”来存储相同问题的答案

C++代码

// 记忆化搜索
class Solution 
{
public:
    int uniquePaths(int m, int n) 
    {
        vector<vector<int>> memo(m + 1, vector<int>(n + 1, 0));
        return dfs(m, n, memo);
    }

    int dfs(int m, int n, vector<vector<int>>& memo) 
    {
        if (memo[m][n] != 0)
            return memo[m][n];

        if (m == 0 || n == 0)
            return 0;
        if (m == 1 && n == 1) 
        {
            memo[m][n] = 1;
            return 1;
        }

        memo[m][n] = dfs(m - 1, n, memo) + dfs(m, n - 1, memo);
        return memo[m][n];
    }
};



// 动态规划
class Solution 
{
public:
    int uniquePaths(int m, int n) 
    {
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        dp[0][1] = 1;
        for(int i = 1; i <= m; i++)
            for(int j = 1; j <= n; j++)
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                
        return dp[m][n];
    }
};

最长递增子序列

题目：最长递增子序列

思路

递归

优化

正常递归时间复杂度太高，借助一个“备忘录”来存储相同问题的答案

C++代码

// 记忆化搜索
class Solution 
{
public:
    int lengthOfLIS(vector<int>& nums) 
    {
        int n = nums.size();
        vector<int> memo(n, 0);
        int ret = 0;
        for(int i = 0; i < n; i++)
            ret = max(ret, dfs(nums, i, memo));
        return ret;
    }
    int dfs(vector<int>& nums, int pos, vector<int>& memo)
    {
        if(memo[pos] != 0) return memo[pos];

        int ret = 1;
        for(int i = pos + 1; i < nums.size(); i++)
        {
            if(nums[i] > nums[pos])
            {
                ret = max(ret, dfs(nums, i, memo) + 1);
            }
        }
        memo[pos] = ret;
        return ret;
    }
};


// 动态规划
class Solution 
{
public:
    int lengthOfLIS(vector<int>& nums) 
    {
        // 动态规划
        // 以某个位置为起点的最长递增子序列
        int n = nums.size();
        vector<int> dp(n, 1);
        int ret = 0;
        // 从后往前填表，因为pos位置的值是依赖pos位置之后的值来决定的
        for(int i = n - 1; i>= 0; i--)
        {
            for(int j = i + 1; j < n; j++)
            {
                if(nums[j] > nums[i])
                    dp[i] = max(dp[i], dp[j] + 1);
            }
            ret = max(ret, dp[i]);
        }
        return ret;
	}
}

猜数字大小 II

题目：猜数字大小 II

思路

递归

优化

正常递归时间复杂度太高，借助一个“备忘录”来存储相同问题的答案

C++代码

class Solution 
{
    int memo[201][201];
public:
    int getMoneyAmount(int n) 
    {
        return dfs(1, n);
    }
    int dfs(int left, int right)
    {
        if(left >= right) return 0;
        if(memo[left][right] !=0 ) return memo[left][right];

        // 选头节点
        int ret = INT_MAX;
        for(int i = left; i < right; i++)
        {
            int x = dfs(left, i - 1);
            int y = dfs(i + 1, right);
            ret= min(ret, i + max(x, y));
        }
        memo[left][right] = ret;
        return ret;
    }
};

矩阵中的最长递增路径

题目：矩阵中的最长递增路径

思路

和上面第三题最长递增子序列思路一样

C++代码

class Solution 
{
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    int m, n;
    int memo[201][201];

public:
    int longestIncreasingPath(vector<vector<int>>& matrix) 
    {
        m = matrix.size(), n = matrix[0].size();
        int ret = 0;
        for (int i = 0; i < m; ++i) 
        {
            for (int j = 0; j < n; ++j) 
            {
                ret = max(ret, dfs(matrix, i, j));
            }
        }
        return ret;
    }

    int dfs(vector<vector<int>>& matrix, int i, int j) 
    {
        if (memo[i][j] != 0)
            return memo[i][j];

        int ret = 1;
        for (int k = 0; k < 4; k++) 
        {
            int x = i + dx[k], y = j + dy[k];
            if (x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j]) 
            {
                ret = max(ret, dfs(matrix, x, y) + 1);
            }
        }
        memo[i][j] = ret;
        return ret;
    }
};