动态规划算法Oj题（一）

骑猪看日落 2023-09-26 10:14 124阅读 0赞

# 系列文章目录 #

[【算法】动态规划][Link 1]  
[动态规划算法Oj题（一）][Oj]  
动态规划算法Oj题（二）  
动态规划算法Oj题（三）

--------------------

### 文章目录 ###

*  系列文章目录
 *  一、斐波那契数列
 *  二、 三角矩阵
 *  三、 字符串分割

# 一、斐波那契数列 #

斐波那契数列是一个满足 **F(n)=F(n - 1)+F(n - 2)**，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。  
现在要求输入一个正整数 n ，请你输出斐波那契数列的第 n 项。数据范围：1≤n≤40。  
**要求：空间复杂度 O(1)，时间复杂度O(n) ，本题也有时间复杂度 O(logn)O(logn) 的解法。**  
题目来源：[牛客网][Link 2]  
  
**方法一**：递归

class Solution{
        
    public:
    int Fibonacci(int n){
        
        // 初始值
    	if (n <= 0){
        
    	return 0;
    	}
    	if (n == 1 || n == 2) {
        
    	return 1;
    	}
    	    // F(n)=F(n-1)+F(n-2)
    	return Fibonacci(n - 2) + Fibonacci(n - 1);
    	}
    };

方法一使用的是递归的思想，理解起来相对简单，代码实现也相对容易，但是递归的方法时间复杂度为O(2^n)，随着n的增大呈现指数增长，效率低下当输入比较大时，可能导致栈溢出，在递归过程中有大量的重复计算。动态规划相比却稍显落后。

**方法二**：动态规划

> 状态：F(n)  
> 状态递推：F(n)=F(n-1)+F(n-2)  
> 初始值：F(1)=F(2)=1  
> 返回结果：F(N)

class Solution
    {
        
    public:
    	int Fibonacci(int n)
    	{
        
        	// 初始值
    		if (n <= 0)
    			return 0;
    		if (n == 1 || n == 2) 
    			return 1;
    		
    		int fn1 = 1;
    		int fn2 = 1;
    		int result = 0;
    		for (int i = 3; i <= n; i++)
    		{
        
    		    // F(n)=F(n-1)+F(n-2)
    			result = fn2 + fn1;
    	        // 更新值
    			fn1 = fn2;
    			fn2 = result;
    		}
    		return result;
    	}
    };

其实F(n)只与它相邻的前两项有关，所以没有必要保存所有子问题的解只需要保存两个子问题的解就可以，此方法方法的空间复杂度将为O(1)。

# 二、 三角矩阵 #

描述  
给出一个三角形，计算从三角形顶部到底部的最小路径和，每一步都可以移动到下面一行相邻的数字，例如，给出的三角形如下：

> \[\[20\],\[30,40\],\[60,50,70\],\[40,10,80,30\]\]

最小的从顶部到底部的路径和是20 + 30 + 50 + 10 = 110。

**状态：**  
子状态：从(0,0)到(1,0),(1,1),(2,0),…(n,n)的最短路径和  
F(i,j): 从(0,0)到(i,j)的最短路径和  
**状态递推：**  
F(i,j) = min( F(i-1, j-1), F(i-1, j)) + triangle\[i\]\[j\]  
**初始值：**  
F(0,0) = triangle\[0\]\[0\]  
**返回结果：**  
min(F(n-1, i))

class Solution {
        
    public:
        int minimumTotal(vector<vector<int> > &triangle) {
        
            if(triangle.empty())
                return 0;
            /*
            //方法一：自上向下
            int row = triangle.size();
            int col = triangle[0].size();
             
            for(int i = 1; i < row; i++)
            {
                for(int j = 0; j <= i; j++)
                {
                    if(j==0)
                        triangle[i][j] = triangle[i-1][j] + triangle[i][j];
                    else if(j==i)
                        triangle[i][j] = triangle[i-1][j-1] + triangle[i][j];
                    else
                        triangle[i][j] = min(triangle[i-1][j-1], triangle[i-1][j]) + triangle[i][j];
                }
            }
             
            //min
            int minSum = triangle[row - 1][0];
            for(int j = 1; j < row; j++)
            {
                minSum = min(minSum, triangle[row - 1][j]);
            }
            return minSum;
            */
             
            //方法二：自下向上
            int row = triangle.size();
            for(int i = row - 2; i >= 0; --i)
            {
        
                for(int j = 0; j <= i ;++j)
                {
        
                    triangle[i][j] = min(triangle[i+1][j], triangle[i+1][j+1]) + triangle[i][j];
                }
            }
             
            return triangle[0][0];
        }
    };

# 三、 字符串分割 #

**描述**  
给定一个字符串s和一组单词dict，判断s是否可以用空格分割成一个单词序列，使得单词序列中所有的单词都是dict中的单词（序列可以包含一个或多个单词）。  
例如:

> 给定s = “nowcode”  
> dict = \[“now”, “code”\]  
> 返回true，因为"nowcode"可以被分割成"now code"。

来源：[牛客网][Link 3]

**分析：**

**状态：**  
子状态：前1，2，3，…,n个字符能否根据词典中的词被成功分词  
F(i): 前i个字符能否根据词典中的词被成功分词  
**状态递推：**  
F(i): true\{j <i && F(j) && substr\[j+1,i\]能在词典中找到\} OR false  
在j小于i中，只要能找到一个F(j)为true，并且从j+1到i之间的字符能在词典中找到，则F(i)为true。  
**初始值：**  
对于初始值无法确定的，可以引入一个不代表实际意义的空状态，作为状态的起始空状态的值需要保证状态递推可以正确且顺利的进行，到底取什么值可以通过简单 的例子进行验证。  
F(0) = true

**返回结果**：F(n)

基本原理是将一个字符串分成两个部分，如果两个部分都满足要求，则总的字符串是满足要求的，这两个部分又可以继续去判断。具体代码如下：

class Solution {
        
    public:
        bool wordBreak(string s, unordered_set<string> &dict) {
        
            if(dict.empty())
                return false;
            if(s.empty())
                return false;
            vector<bool> canBreak(s.length() + 1, false);
             
            //初始化
            canBreak[0] = true;
            for(int i = 1; i <= s.length(); i++)
            {
        
                // j < i && F(j) && [j + 1, i];
                for(int j = 0; j < i; j++)
                {
        
                    if(canBreak[j] && dict.find(s.substr(j, i-j)) != dict.end())
                    {
        
                        canBreak[i] = true;
                        break;
                    }
                }
            }
             
            return canBreak[s.length()];       
        }
    };

[Link 1]: http://t.csdn.cn/FmaQI
[Oj]: http://t.csdn.cn/ghUjA
[Link 2]: https://www.nowcoder.com/practice/c6c7742f5ba7442aada113136ddea0c3?tpId=13&tqId=11160&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking
[Link 3]: https://www.nowcoder.com/practice/5f3b7bf611764c8ba7868f3ed40d6b2c?tpId=46&tqId=29041&tPage=1&rp=1&ru=/ta/leetcode&qru=/ta/leetcode/question-ranking