算法实验六 综合实验

实验题目： 公主传说-高塔

题目描述：
公主又被抓走了，各位王子听到了很高兴，Yes，又可以救美了。于是，王子们蜂拥而至。但是他们很快发现各自陷入了一个独立魔法空间，空间之间可以互相看见和交流，但是不能传送任何物品。每个王子的面前都有一堆积木，每个积木是个立方体，每个人分到的积木的个数和尺寸是随机的。王子们很快后悔了，觉得进来之前应该先来个拳头剪刀布什么的，因为进来的人越多越麻烦。积木的旁边放着一张纸条，上面写着游戏规则，只有他们合作解决了问题，才能一起破关而出。规则规定如下：每个王子需要用自己的积木搭建一个高塔（不需要全部用完积木），高塔下面的积木不比上面的积木小。如果所有人搭的塔高度一样，而且是所能实现的最大高度，魔法才会解除。
输入要求：
第一行是一个整数N(N<=100)，表示一共有几个王子。以下N行每行是一系列非负整数，用一个空格分隔，给出某个王子所有积木的棱长。用-1结束。一个王子的积木不超过100块，每块积木的棱长不超过100。
输出要求：
一个整数，表示最后积木高塔的最大可能的高度。如果找不到合适的方案，则输出0。
实验代码

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

int n, len, min_high = 2e9, w[105], ans[10005];
// w数组为每一城堡积木的高度 ans数组为达到高度i的个数
bool dp[10005];
// Dp嘛
int main() {
    cin >> n; //n个城堡
    for (int k = 1;k <= n;k++)// 每一个城堡
    {
        //memset(w,0,sizeof(w)); // 其实不用
        memset(dp, 0, sizeof(dp)); // 以免前一个影响当前城堡
        int cnt = 0, high = 0; //cnt为积木个数，high为高度~
        while (1)
        {
            cin >> len; //输入len
            if (len == -1) break; // 输入完了~
            w[++cnt] = len; // 存高度~
            high += len; // 算高度~
        }
        // 开始DP！
        dp[0] = 1; // 初始状态，高度0可达
        for (int i = 1;i <= cnt;i++)// 物品维（cnt个积木）
            for (int j = high;j >= w[i];j--)// 容量~倒叙枚举压物品维 枚举到物品大小
                dp[j] |= dp[j - w[i]]; //动态转移方程
        min_high = min(min_high, high); // 最小值~
        for (int i = high;i >= 1;i--) // 检查一下能否达到高度
            if (dp[i] == 1) ans[i]++;// 加到ans数组~
    }
    for (int i = min_high;i >= 1;i--)// 看看那个高度可以所有达到！
        if (ans[i] == n)
        {
            cout << i;// 输出
            return 0;
        }
    cout << "0";//没有，输出0
    return 0;
}

实验题目： 公主传说-城堡

题目描述
公主被魔王抓走了，关押在一个城堡，城堡是ABC的立方体。公主被关在(0,0,0)的位置,离开城堡的出口在(A-1,B-1,C-1)的位置。有一天，公主得知魔王会离开城堡T分钟，这是唯一的一次逃跑机会，但是城堡就像一个三维的迷宫，有些地方不能通行。公主每分钟能从一个坐标走到相邻的六个坐标中的其中一个。现在给你城堡的地图，请你计算出公主能否在魔王回来前离开城堡（只要T分钟刚好走到出口就算离开城堡）。如果可以请输出需要多少分钟才能离开，如果不能则输出-1。
输入要求：
输入数据的第一行是一个正整数K，表明测试数据的数量。每组测试数据的第一行是四个正整数A，B，C和T(1<=A,B,C<=50,1<=T<=1000)，它们分别代表城堡的大小和魔王回来的时间。然后是A块输入数据(先是第0块,然后是第1块,第2块…)，每块输入数据有B行，每行有C个正整数，代表三维迷宫的布局。其中0代表路，1代表墙。
输出要求：
对于每组测试数据，如果公主能够在魔王回来前离开城堡，那么请输出最少需要多少分钟，否则输出-1。
实验代码：

#include<bits/stdc++.h>
using namespace std;
bool mark[50][50][50]; //标记数组
int maze[50][50][50];  //保存立方体信息
struct N
{ //状态结构体
    int x, y, z;
    int t;
};
queue<N> Q; //队列,队列中的元素为状态
//坐标变换数组,由坐标(x,y,z)扩展得到的新坐标均可通过
// (x + go[i][0], y + go[i][1], z + go[i][2]) 得到
int go[][3] = {
    1, 0, 0,
    -1, 0, 0,
    0, 1, 0,
    0, -1, 0,
    0, 0, 1,
    0, 0, -1 };
int BFS(int a, int b, int c)
{ //广度优先搜索,返回其最少耗时
    while (Q.empty() == false)
    {                      //当队列中仍有元素可以扩展时循环
        N now = Q.front(); //得到队头状态
        Q.pop();           //从队列中弹出队头状态
        for (int i = 0; i < 6; i++)
        { //依次扩展其六个相邻节点
            int nx = now.x + go[i][0];
            int ny = now.y + go[i][1];
            int nz = now.z + go[i][2]; //计算新坐标
            if (nx < 0 || nx >= a || ny < 0 || ny >= b || nz < 0 || nz >= c)
                continue; //若新坐标在立方体外,则丢弃该坐标
            if (maze[nx][ny][nz] == 1)
                continue; //若该位置为墙,则丢弃该坐标
            if (mark[nx][ny][nz] == true)
                continue; //若包含该坐标的状态已经被得到过, 则丢弃该状态
            N tmp;        //新的状态
            tmp.x = nx;
            tmp.y = ny;
            tmp.z = nz;              //新状态包含的坐标
            tmp.t = now.t + 1;       //新状态的耗时
            Q.push(tmp);             //将该状态放入队列
            mark[nx][ny][nz] = true; //标记该坐标
            if (nx == a - 1 && ny == b - 1 && nz == c - 1)
                return tmp.t; //若该坐标即为终点, 可直接返回其耗时
        }
    }
    return -1; //若所有的状态被查找完后,仍得不到所需坐标,则返回-1
}
int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        int a, b, c, t;
        scanf("%d%d%d%d", &a, &b, &c, &t); //输入
        for (int i = 0; i < a; i++)
        {
            for (int j = 0; j < b; j++)
            {
                for (int k = 0; k < c; k++)
                {
                    scanf("%d", &maze[i][j][k]); //输入立方体信息
                    mark[i][j][k] = false;       //初始化标记数组
                }
            }
        }
        while (Q.empty() == false)
            Q.pop();          //清空队列
        mark[0][0][0] = true; //标记起点
        N tmp;
        tmp.t = tmp.y = tmp.x = tmp.z = 0; //初始状态
        Q.push(tmp);
        //将初始状态放入队列
        int rec = BFS(a, b, c); //广度优先搜索
        if (rec <= t)
            printf("%d\n", rec); //若所需时间符合条件,则输出
        else
            printf("-1\n"); //否则输出-1
    }
    return 0;
}