算法题：dfs总结

瓜农与花农

已于 2024-04-22 15:14:04 修改

阅读量706

点赞数 17

CC 4.0 BY-SA版权

文章标签：算法

于 2024-03-22 14:31:31 首次发布

本文链接：https://blog.csdn.net/m0_52043808/article/details/136937974

记忆化递归：

（1）参数个数为n，申请一个n维数组（哈希表），确保能够根据参数直接访问数组（哈希表）的值

（2）函数体：

如果数组（哈希表）已经记录过参数对应的函数值，直接返回该值

在所有出现return前，return的值记录到数组（哈希表）中

隐形回溯：

如果写成dfs(现在状态+（）)

//括号里为下一个状态的参数，这里隐含了回溯

记忆化递归的必要性：

普通的递归可能会重复求解某一值，类似斐波那契数列。同样的子问题可能会被求解多次，这样就会很慢很慢很慢

解决方法：我们把历史求解（子问题）记录下来，如果下次需要求解子问题，那么直接取出就好。其时间复杂度为O（1）

根据n-1的状态推出第n个状态。

Leetcode 22. 括号生成（递归+去重）

当n=1时，返回()

递归求n-1时的结果，由左右括号配对可知每一个结果字符串的长度都为2*（n-1)。在每一个结果的每一个位置+“（）”，再经map去重就是n时的结果。

vector<string> generateParenthesis(int n):
  unordered_map<string,int>map;
  vector<string>res;
  if(n==1) return {"()"}
  vector<string>vec = generateParenthesis(n-1);
  string temp;
  for(auto&s:vec)
    for(int i=0;i<2*(n-1);i++)
    //字符串的连接
        temp=s.substr(0,i)+"()"+s.substr(i,2*(n-1));
  if(map.find(temp)==map.end())
      map[temp]=1;
      res.push_back(temp);
  return res;

做选择

在一个n×m的网格状地宫中，每个格子内有一件具有特定价值的宝贝。小明从地宫的左上角出发，只能向右或向下移动，直至到达右下角的出口。在移动过程中，当他经过一个格子时，若该格子中的宝贝价值大于他当前手中任意一件宝贝的价值，他可以选择拿取这件宝贝（也可以选择不拿）。目标是让小明在走出地宫时，手中恰好拥有k件宝贝。请你计算出小明在满足上述条件下，走到终点能够成功获取k件宝贝的不同行动方案数量。

dfs(1,1,-1,0)表示从起点到终点的结果。

由于只能向右或向下移动，所以移动一直是单向的，不需要有vis标志。

#include<bits/stdc++.h>
using namespace std;
int mat[60][60];
int n,m,k;
bool check(int x,int y)
{
	return (x>=1&&x<=n&&y>=1&&y<=m);
} 
long long dp[60][60][60][15];
long long dfs(int x,int y,int maxv,int cnt)
{
	if(dp[x][y][maxv+1][cnt]!=-1)//注意1
		return dp[x][y][maxv+1][cnt];
	if(cnt>k)//如果手里有k+1件宝贝，越界，返回 
		return dp[x][y][maxv+1][cnt]=0;
	if(!check(x,y))//越界，修正
		return dp[x][y][maxv+1][cnt]=0;
	if(x==n&&y==m)//到达终点 
	{
		if(mat[x][y]>maxv)//能拿
		{
		   if(cnt==k)//如果手里已经有看件宝贝 
		    return dp[x][y][maxv+1][cnt]=1;//在终点处选择不拿有一种方案 
		   else if(cnt==k-1)return dp[x][y][maxv+1][cnt]=1;//在终点处选择拿，有一种方案 
		   else return dp[x][y][maxv+1][cnt]=0;
		}
		else//不能拿 
		{
			if(cnt==k)return dp[x][y][maxv+1][cnt]=1;//如果手里已经有k件宝贝，选择不拿，有一种方案
			else return dp[x][y][maxv+1][cnt]=0;
		} 
	}
	
	if(mat[x][y]>maxv)
		return dp[x][y][maxv+1][cnt]=dfs(x+1,y,mat[x][y],cnt+1)+dfs(x,y+1,mat[x][y],cnt+1)+dfs(x+1,y,maxv,cnt)+dfs(x,y+1,maxv,cnt);
	else
		return dp[x][y][maxv+1][cnt]=dfs(x+1,y,maxv,cnt)+dfs(x,y+1,maxv,cnt);
}
int main()
{
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			cin>>mat[i][j];
		}
	}
	memset(dp,-1,sizeof(dp));//memset的用法
	cout<<dfs(1,1,-1,0)%1000000007 ;//注意2，要取模
	
 
 }

K进制数

具体来说，给定整数N表示数的位数，以及基数K（K≥2），需要确定并求出所有满足以下条件的K进制数的数量：数字总共有N位；在这N位的K进制表示中，任何相邻的两位数字都不会同时是0。给定两个数N和K, 要求计算包含N位数字的有效K-进制数的总数。

int dfs(int idx,bool pre){
  if(dp[idx][pre]!=-1)return dp[idx][pre];
  if(idx==n){
      if(pre)return dp[idx][pre]=k-1;
      else return dp[idx][pre]=k;
  }
  if(pre)
     return dp[idx][pre] = (k-1)*dfs(idx+1,false); 
  else
     return dp[idx][pre] = (k-1)*dfs(idx+1,false)+dfs(idx+1,true)
}
dfs(1,0);

剪格子

方格分割

6x6的方格，沿着格子的边线剪开成两部分。要求这两部分的形状完全相同。

试计算：包括这 3种分法在内，一共有多少种不同的分割方法。注意：旋转对称的属于同一种分割法。

蓝桥杯2013c++真题：振兴中华

深度优先搜索：岛屿的周长

如果陆地有4个邻接陆地，那么这个陆地周长算为0；如果陆地有3个邻接陆地，那么这个陆地周长算1；如果陆地有2个邻接陆地，那么这个陆地周长算2；如果陆地有1个邻接陆地，那么这个陆地周长算3；如果陆地没有邻接陆地，那么这个路径周长算4。

vector<vector<int>>G;
int n, m;
bool vis[105][105];
int res=0;
void dfs(int x, int y)
   if (!(x >= 0 && y >= 0 && x < n && y < m))return;
   if (G[x][y]==0)return
   if (vis[x][y])return
   int cnt = 0
   vis[x][y] = true
   if (x - 1 >= 0 && G[x - 1][y] == 1)cnt++
   if (x + 1 < n && G[x + 1][y] == 1)cnt++
   if (y - 1 >= 0 && G[x][y - 1] == 1)cnt++
   if (y + 1 < m && G[x][y + 1] == 1)cnt++
   res+=4-cnt 
   dfs(x + 1, y)
   dfs(x - 1, y)
   dfs(x, y + 1)
   dfs(x, y - 1)

int islandPerimeter(vector<vector<int>>& grid)
        G = grid;
        n = grid.size();
        m = grid[0].size();
        memset(vis, 0, sizeof(vis));
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                if (G[i][j] == 1)
                    dfs(i,j);
                    break;