题解 Mayan游戏

本文介绍了一道洛谷平台上的搜索剪枝题目,并详细展示了如何通过暴力下落和暴力消除来解决该问题。使用C++实现了一个递归深度优先搜索算法,包括状态检查、状态转移等关键步骤。

@luogu


搜索剪枝题,每一次暴力下落,暴力消除

#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 10
#define ll long long
#define max(x,y) ((x)>(y) ? (x) : (y))
#define min(x,y) ((x)<(y) ? (x) : (y))
using namespace std;

inline int getint() {
    int t=0,p;
    char ch=getchar();
    for(;ch!='-' && !(ch>='0' && ch<='9');ch=getchar());
    if(ch=='-') p=-1,ch=getchar();
    else p=1;
    for(;ch>='0' && ch<='9';ch=getchar()) {
        t=t*10+ch-48;
    }
    return t*p;
}

int n,a[8][N];

inline void fall() {
    bool flag;
    do {
        flag=false;
        for(register int i=1;i<=5;i++) {
            for(register int j=2;j<=7;j++) if(a[i][j] && !a[i][j-1]) {
                a[i][j-1]=a[i][j];a[i][j]=0;flag=true;
            }
        }
    } while(flag);
}

bool f[8][N];

inline bool check() {
    memset(f,false,sizeof f);
    bool flag=false;
    for(int i=1;i<=5;i++) {
        for(register int j=1;j<=7;j++) if(a[i][j]) {
            if(a[i-1][j]!=0 && a[i-1][j]==a[i][j] && a[i][j]==a[i+1][j]) {
                f[i-1][j]=f[i][j]=f[i+1][j]=true;
            }
            if(a[i][j-1]!=0 && a[i][j]==a[i][j-1] && a[i][j]==a[i][j+1]) {
                f[i][j-1]=f[i][j+1]=f[i][j]=true;
            }
        }
    }
    for(int i=1;i<=5;i++) {
        for(register int j=1;j<=7;j++) {
            if(f[i][j]) a[i][j]=0,flag=true;
        }
    }
    return flag;
}

struct Node {
    int x,y,z;
} ans[N];

bool flag;

//void debug(int x,int y,int t) {
//  if(t==n-1 && x==4 && y==2) {
//      for(int i=1;i<=5;i++) {
//          for(int j=1;j<=7;j++) {
//              printf("%d ",a[i][j]);
//          }
//          printf("\n");
//      }
//  }
//}

void dfs(int t) {
    if(flag) return;
    if(t==0) {
        flag=true;
        for(int i=1;i<=5;i++) {
            if(a[i][1]!=0) {flag=false;break;}
        }
        return;
    }
    for(int i=1;i<=5;i++) {
        for(int j=1;a[i][j];j++) {
            if(i!=5 && a[i][j]!=a[i+1][j] && a[i][j]) {   //剪枝
                int b[8][N];
                memcpy(b,a,sizeof a);
                swap(a[i][j],a[i+1][j]);
                ans[n-t+1]=(Node){i-1,j-1,1};
                fall();
                while(check()) fall();
                dfs(t-1);
                memcpy(a,b,sizeof a);
                if(flag) return;
            }
            if(i!=1 && a[i][j] && a[i-1][j]==0) {       //剪枝
                int b[8][N];
                memcpy(b,a,sizeof a);
                swap(a[i][j],a[i-1][j]);
                ans[n-t+1]=(Node){i-1,j-1,-1};
                fall();
                while(check()) fall();
                dfs(t-1);
                memcpy(a,b,sizeof a);
                if(flag) return;
            }
        }
    }
}

int main() {
//  freopen("mayan.in","r",stdin);
//  freopen("mayan.out","w",stdout);
    n=getint();
    memset(a,0,sizeof a);
    for(int i=1;i<=5;i++) {
        int D=getint();int j=1;
        while(D) {a[i][j++]=D;D=getint();}
    }
    dfs(n);
    if(flag) {
        for(int i=1;i<=n;i++) {
            printf("%d %d %d\n",ans[i].x,ans[i].y,ans[i].z);
        }
    } else {
        printf("-1\n");
    }
    return 0;
}
### 地下城游戏题解与算法分析 #### 题目概述 地下城游戏问题的核心在于骑士需要从左上角移动到右下角,过程中会遇到不同的房间。这些房间可能包含正数(增加健康点数)、负数(减少健康点数)或零(无影响)。目标是计算骑士在起点所需的最小初始健康点数,以确保能够成功到达终点[^4]。 #### 动态规划思路 动态规划是解决该问题的主要方法。由于骑士必须从终点倒推至起点,因此动态规划表 `dp[i][j]` 定义为从位置 `(i, j)` 到达终点所需的最小健康点数。通过逆向分析,可以避免复杂的前向状态转移逻辑[^2]。 #### 状态转移方程 状态转移方程如下: ```cpp dp[i][j] = max(min(dp[i+1][j], dp[i][j+1]) - dungeon[i][j], 1); ``` - `min(dp[i+1][j], dp[i][j+1])` 表示从当前格子出发时,选择向下或向右移动中所需最小健康点数较小的方向。 - 减去 `dungeon[i][j]` 是因为当前格子的影响需要被考虑。 - 使用 `max(..., 1)` 确保骑士在任何情况下健康点数都不低于 1[^3]。 #### 边界条件 为了简化边界处理,通常会在动态规划表的底部和右侧额外添加一行和一列,并初始化为一个足够大的值(如 `INF=0x3f3f3f3f`),以表示超出边界的情况。同时,将 `dp[m-1][n]` 和 `dp[m][n-1]` 初始化为 1,表示从终点出发时骑士至少需要 1 点健康点数[^3]。 #### 代码实现 以下是基于 C++ 的完整实现: ```cpp class Solution { public: int calculateMinimumHP(vector<vector<int>>& dungeon) { int m = dungeon.size(); int n = dungeon[0].size(); // 定义 INF 为足够大的值 int INF = 0x3f3f3f3f; // 创建动态规划表,多开一行和一列 vector<vector<int>> dp(m + 1, vector<int>(n + 1, INF)); // 初始化边界条件 dp[m][n - 1] = dp[m - 1][n] = 1; // 倒序填表 for (int i = m - 1; i >= 0; --i) { for (int j = n - 1; j >= 0; --j) { dp[i][j] = max(min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j], 1); } } return dp[0][0]; } }; ``` #### 时间与空间复杂度 - **时间复杂度**:O(m * n),其中 m 和 n 分别为地下城网格的行数和列数。 - **空间复杂度**:O(m * n),用于存储动态规划表 `dp`。可以通过优化将空间复杂度降低至 O(n),但此处未展示优化版本。 #### 注意事项 1. 在进入负值的格子时,骑士的健康点数必须大于等于 1 才能继续前进。 2. 在进入正值的格子之前,骑士的健康点数也必须至少为 1,不能为负值。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值