我用的是广度优先搜索，核心代码如下

// BFS搜索函数：寻找从起点到终点的最优路径
// 参数：bh(最佳剩余生命值，引用传递)，bs(最佳步数，引用传递)
void bfs(int &bh, int &bs) {
    queue<node> q;
    // 初始化队列，起点(0,0)，初始生命值x，步数0
    q.push({0, 0, x, 0});
    // 记录起点的最大生命值和最小步数
    mh[0][0] = x;
    ms[0][0] = 0;
    // 初始化最佳结果：-1表示未到达终点，INT_MAX表示无效步数
    bh = -1;
    bs = INT_MAX;
    
    // 队列不为空时继续搜索
    while (!q.empty()) {
        // 取出队首元素
        node c = q.front();
        q.pop();
        
        // 判断是否到达终点也就是右下角
        if (c.x == n-1 && c.y == m-1) {
            // 更新结果：优先保证生命值最大，相同则相同则取步数最小
            if (c.h > bh) {
                bh = c.h;
                bs = c.s;
            } else if (c.h == bh && c.s < bs) {
                bs = c.s;
            }
            continue; // 已处理终点，不用扩展了
        }
        
        // 探索四个方向(上、右、下、左)
        for (int d = 0; d < 4; d++) {
            int nx = c.x + dx[d]; // 新x坐标
            int ny = c.y + dy[d]; // 新y坐标
            
            // 检查越界
            if (nx<0 || nx>=n || ny<0 || ny>=m) continue;
            // 障碍物检查
            if (mp[nx][ny] == -1) continue;
            
            // 计算新生命值
            int nh = c.h;
            if (mp[nx][ny] > 0) nh -= mp[nx][ny];
            // 生命值必须始终大于0，要不然这辈子都走不出去
            if (nh <= 0) continue;
            
            // 计算新步数：当前步数+1
            int ns = c.s + 1;
            if (nh > mh[nx][ny]) {
                mh[nx][ny] = nh;
                ms[nx][ny] = ns;
                q.push({nx, ny, nh, ns});
            } else if (nh == mh[nx][ny] && ns < ms[nx][ny]) {
                ms[nx][ny] = ns;
                q.push({nx, ny, nh, ns});
            }
        }
    }
}