【刷题笔记4】

动态规划题目汇总

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

void rec(形参列表) { if(test) return; //边界条件 //！！！注意！！！ 递归一定要有边界条件！！！否则就会死循环！！！ rec(实参列表) //递归调用 语句序列2 //递归返回段(回溯) } 有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。例：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。一月的时候有一只兔子，假如兔子都不死，问第n个月的兔子总数为多少？ 输入一个int型整数表示第n个月 输出对应的兔子总数 #include <iostream> 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; } 把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 <iostream> 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); } n*m的棋盘格子（n为横向的格子数，m为竖向的格子数）从棋盘左上角出发沿着边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。 #include <iostream> 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; } };

BFS（广度优先搜索算法） #include <iostream> #include <cstdio> #include <queue> using namespace std; int Map[5][5]; //定义地图大小 int dir[4][2]= {1,0,-1,0,0,-1,0,1}; //定义方向 int n,m,ans; struct node { int x,y,step; } now,nextt; //保存走步 int BFS(int x,int y) { queue<node>q; int xx,yy,zz; Map[x][y]=2; //走过初始点 now.x=x; now.y=y; now.step=0; q.push(now); //从当前点开始 while(!q.empty()) { now=q.front(); q.pop(); for(int i=0; i<4; i++) //遍历四个方向 { xx=now.x+dir[i][0]; yy=now.y+dir[i][1]; //走一步 if(xx>=0&&xx<5&&yy>=0&&yy<5&&Map[xx][yy]!=1&&Map[xx][yy]!=2) //可以走 { nextt.x=xx; nextt.y=yy; nextt.step=now.step+1; //步数加一 Map[now.x][now.y]=2; //走过一个点 if(Map[xx][yy]==3) //到达终点 return nextt.step; q.push(nextt); } for(int i=0; i<5; i++){ //打印地图 for(int j=0; j<5; j++) cout << Map[i][j]; cout << endl; } cout << endl; } } return -1; //走不过去 } int main() { for(int i=0; i<5; i++) //输入地图 for(int j=0; j<5; j++) cin >> Map[i][j]; Map[4][4]=3; //定义终点 ans=BFS(0,0); cout << ans<< endl; return 0; }

自己重构的走迷宫的代码：

#include <algorithm> #include <iostream> #include <cstdio> #include <queue> #include <vector> using namespace std; int n,m; int zuiyou; vector<vector<int>>maze; //定义地图大小 struct point{ int x,y; }; int fangxiang[4][2]={{-1,0},{1,0},{0,-1},{0,1}}; //定义上下左右 vector<vector<int> >path(5,vector<int>(5));//记录每次的方向,0,1,2,3对应上下左右 vector<vector<int>>fan; struct node{ int x,y,z; }now, nextt;; void bfs(int x,int y) { // vector<vector<int>> path(n, vector<int>(m)); maze[x][y]=2; queue <node> q; now.x=x; now.y=y; now.z=0; q.push(now); while(!q.empty()) { now=q.front(); maze[now.x][now.y]=2; q.pop(); for( int i=0;i<4;i++) { int xx=now.x+fangxiang[i][0]; int yy=now.y+fangxiang[i][1]; if(xx>=0&&xx<n&&yy>=0&&yy<m&&maze[xx][yy]==3) { path[xx][yy]=i; if(maze[xx][yy]==3) zuiyou=now.z+1; } if(xx>=0&&xx<n&&yy>=0&&yy<m&&maze[xx][yy]==0) { nextt.x=xx; nextt.y=yy; nextt.z=now.z+1; q.push(nextt); path[xx][yy]=i; } } } int ii=n-1,jj=m-1; fan.push_back({ii,jj}); while(ii!=0||jj!=0) { int num=path[ii][jj]; ii=ii-fangxiang[num][0]; jj=jj-fangxiang[num][1]; fan.push_back({ii,jj}); } reverse(fan.begin(),fan.end()); } int main() { cin>>n>>m; maze=vector<vector<int>>(n,vector<int>(m)); //定义地图大小 for(int i=0;i<n;i++) { for(int j=0;j<m;j++) { cin>>maze[i][j]; } } maze[4][4]=3; bfs(0, 0); cout<<zuiyou<<endl;; cout<<endl; for(auto t:fan) { cout<<t[0]<<","<<t[1]; cout<<endl; } }

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

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