【刷题笔记4】

动态规划题目汇总

斐波那契数列：1，1，2，3，5，8，13……
递归一把解决三类问题：1.数据定义是按照递归的（斐波那契数列）。2.问题解法是按递归算法实现的。 3.数据形式是按照递归形式定义的。
递归的一般形式：

void rec(形参列表)
{
	if(test) return;  //边界条件
    //！！！注意！！！  递归一定要有边界条件！！！否则就会死循环！！！
    rec(实参列表)     //递归调用
    语句序列2         //递归返回段(回溯)
}

1. 有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。例：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。一月的时候有一只兔子，假如兔子都不死，问第n个月的兔子总数为多少？
   输入一个int型整数表示第n个月
   输出对应的兔子总数

#include 
using namespace std;
int total(int n);
int total(int n)
{
    if(n==1||n==2)//这个叫边界条件
    return 1;
    else
    return total(n-1)+total(n-2);//递归调用
}
int main() {
    //斐波那契数列
    int n,num;
    cin>>n;
    num=total(n);
    cout<<num;
}

2. 把m个同样的苹果放在n个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？ 注意：如果有7个苹果和3个盘子，（5，1，1）和（1，5，1）被视为是同一种分法。

解题思路：
假设有m个苹果和n个盘子，我们可以将问题分为两种情况： 1. 盘子中至少有一个盘子为空：这种情况下，我们可以将m个苹果放在n-1个盘子中，即将问题转化为将m个苹果放在n-1个盘子中的分法。所以，这种情况下的分法数为f(m, n-1)。 2. 盘子中所有盘子都有苹果：这种情况下，我们可以将每个盘子中放入一个苹果，然后将剩余的m-n个苹果放在n个盘子中，即将问题转化为将m-n个苹果放在n个盘子中的分法。所以，这种情况下的分法数为f(m-n, n)。 综上所述，将m个苹果放在n个盘子中的分法数为f(m, n) = f(m, n-1) + f(m-n, n)。
边界条件： - 当m=0时，表示没有苹果需要放入盘子中，所以只有一种分法，即所有盘子都为空。 - 当n=0时，表示没有盘子可以放苹果，所以没有分法。 根据上述递推关系和边界条件，可以使用递归或动态规划的方法来求解。

#include 
using namespace std;

int fn(int m,int n)
{
    if(n<1) return 0;
    if(m<0) return 0;
    if(m==0) return 1;
    return fn(m-n,n)+fn(m,n-1);//没有空盘子+有1个空盘子
}

int main() {
    int m,n;
    cin>>m>>n;
    cout<<fn(m,n);
}

3. n*m的棋盘格子（n为横向的格子数，m为竖向的格子数）从棋盘左上角出发沿着边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。

#include 
using namespace std;
int digui(int x,int y)
{
    if(x==1||y==1)//只有一行或者一列的时候，就有x+y种方法
    return x+y;    //否则就往上或者往下走一步。
    return digui(x-1,y)+digui(x,y-1);

	//if(x==0)
	//return 1;
	//if(y==0)
	//return 1;
    //return x+y;    //否则就往上或者往下走一步。
    //return digui(x-1,y)+digui(x,y-1);




	//if(m<0||n<0)
    //return 0;
    //else if(n==1&&m==0)
    //return 1;
    //else if(m==1&&n==0)
    //return 1;
    //else  
    //return(digui(m-1, n)+digui(m,n-1));
}

int main() {
    int m,n;
    cin>>n>>m;
    cout<<digui(m,n);

}

最长递增子序列问题：

4.

class Solution {
  public:
    int LIS(vector<int>& arr) {
        if (arr.empty())
            return 0;
        int N = arr.size();
        vector<int>dp(N, 1);
        int maxLen = 1;
        for (int i = 1; i < N; i++) {
            for (int j = 0; j < i; j++) {
                if (arr[i] > arr[j]) {
                    dp[i] = max(dp[i], dp[j] + 1); //长度加1
                }
            }
            maxLen = max(maxLen, dp[i]);//更新最大长度
        }
        return maxLen;
    }
 
};

5. DFS（深度优先搜索算法）：一般用于查找图中的路径、连通性检测、拓扑排序等。
   深度优先搜索使用栈（Stack）数据结构来保存需要探索的节点。每次访问一个节点时，将其标记为已访问，并将其未访问的邻居节点压入栈中。然后从栈中弹出一个节点，继续访问该节点的未访问邻居节点，直到栈为空。

如果需要找到最短路径，可以考虑使用其他算法，如广度优先搜索（BFS）或 Dijkstra 算法。一般最小步数、最短距离、最小操作次数等问题采用BFS。