每日总结3.19

2022年第十三届蓝桥杯B组省赛真题

1.李白买酒问题

dfs法

int dfs(int n,int m,int dr)
{
    if(n<0||m<0||dr<0)
    {
        return 0;
    }
    if(dr>m)//剩余酒量大于剩余遇花次数
    {
        return 0;
    }
    if(n==0&&m==1&&dr==1)
    {
        return 1;
    }
    if(dp[n][m][dr]!=-1)//此方案已添加，无需再加，直接返回
    {
        return dp[n][m][dr];
    }
    return dp[n][m][dr]=(dfs(n-1,m,dr*2)+dfs(n,m-1,dr-1))%mod;//遇花和遇店方案相加
    
}
int main()
{
    int n,m;
    memset(dp,-1,sizeof(dp));
    cin>>n>>m;
    cout<<dfs(n,m,2);
}

动态规划
int main()
{
  int N,M;
  cin>>N>>M;
  dp[0][0][2]=1;
  for(int i=0;i<=N;i++)
  {
    for(int j=0;j<=M;j++)
    {
      for(int k=0;k<100;k++)
      {
        if(k%2==0&&i)
        {
          dp[i][j][k]+=dp[i-1][j][k/2]%mod;
        }
        if(j)
        {
          dp[i][j][k]+=dp[i][j-1][k+1]%mod;
        }
      }
    }
  }
  cout<<dp[N][M-1][1];
  return 0;
}

2.扫雷问题

（非标准dfs,八个方向判断）
#include <bits/stdc++.h>
using namespace std;
const int N=105;
int n,m;
int mp[N][N]; 
int dx[8]={-1,-1,0,1,1,1,0,-1};
int dy[8]={0,1,1,1,0,-1,-1,-1};
int dfs(int x,int y)
{
  int num=0;
  if(mp[x][y]==1)
  {
    return 9;
  }
    for(int i=0;i<8;i++)
    {
       if(mp[x+dx[i]][y+dy[i]]==1)
       {
         num++;
       }
    }
  return num;
}

int main()
{
  cin>>n>>m;
  memset(mp,-1,sizeof(mp));
  for(int i=1;i<=n;i++)
  {
    for(int j=1;j<=m;j++)
    {
      cin>>mp[i][j];
    }
  }
  for(int i=1;i<=n;i++)
  {
    for(int j=1;j<=m;j++)
    {
     cout<<dfs(i,j)<<" ";
    }
    cout<<endl;
  }
  return 0;
}

 

蓝桥杯每日真题
数字接龙（√）；

#include <bits/stdc++.h>
using namespace std;

const int N = 11; // 定义棋盘的最大大小为11×11
int n, k; // n为棋盘大小，k为数字循环的范围
int g[N][N]; // 存储棋盘上的数字
int dx[8] = {-1, -1, 0, 1, 1, 1, 0, -1}; // 定义8个方向的x坐标偏移
int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1}; // 定义8个方向的y坐标偏移
string path; // 存储路径的方向编号
bool st[N][N]; // 标记棋盘上的格子是否被访问过
bool edge[N][N][N][N]; // 检查路径是否交叉

// 深度优先搜索函数，用于寻找路径
bool dfs(int a, int b) {
    // 如果到达右下角格子，检查路径长度是否为n*n-1（因为起点不计入路径）
    if (a == n - 1 && b == n - 1)
        return path.size() == n * n - 1;

    st[a][b] = true; // 标记当前格子已访问
    for (int i = 0; i < 8; i++) { // 遍历8个方向
        int x = a + dx[i], y = b + dy[i]; // 计算目标格子的坐标
        // 检查目标格子是否越界、是否访问过、数字是否满足循环序列要求
        if (x < 0 || x >= n || y < 0 || y >= n) continue;
        if (st[x][y]) continue;
        if (g[x][y] != (g[a][b] + 1) % k) continue;
        // 检查路径是否交叉（对于斜向移动，检查是否有反向的路径）
        if (i % 2 && (edge[a][y][x][b] || edge[x][b][a][y])) continue;

        edge[a][b][x][y] = true; // 标记路径
        path += i + '0'; // 将方向编号加入路径
        if (dfs(x, y)) return true; // 递归搜索下一个格子
        path.pop_back(); // 回溯，移除路径中的最后一个方向
        edge[a][b][x][y] = false; // 回溯，取消路径标记
    }
    st[a][b] = false; // 回溯，取消当前格子的访问标记
    return false; // 如果所有方向都无法到达终点，返回false
}

int main() {
    cin >> n >> k; // 输入棋盘大小和数字循环范围
    for (int i = 0; i < n; i++) // 读取棋盘上的数字
        for (int j = 0; j < n; j++)
            cin >> g[i][j];

    // 从起点(0,0)开始搜索路径
    if (!dfs(0, 0))
        cout << -1 << endl; // 如果没有找到路径，输出-1
    else
        cout << path << endl; // 输出路径的方向编号序列

    return 0;
}