数据结构课程设计：室内布线

ultra583

已于 2023-01-30 21:01:30 修改

阅读量300

点赞数 2

分类专栏：数据结构课程设计题解文章标签： c++ 算法数据结构 Powered by 金山文档

于 2023-01-20 18:05:59 首次发布

本文链接：https://blog.csdn.net/abc583/article/details/128737623

版权

数据结构课程设计题解专栏收录该内容

1 篇文章 0 订阅

订阅专栏

题目描述：

题目要求:装修新房子是一项颇为复杂的工程，现在需要写个程序帮助房主设计室内布线的布局。首先，墙壁上插座的位置是固定的。插座间需要有电线相连，而且要布置得整齐美观，即要求每条线都与至少一条墙边平行，且嵌入四壁或者地板(不能走屋顶)。房主要求知道，要将所有插座连通,自己需要买的电线的最短长度。

另外，别忘了每个房间都有门，电线不可以穿门而过。下图给出了一个4插座房间的电线布局。

输入要求：输入由若干组测试数据而成。每组数据的第1行包含房间的长、宽、高和插座的个数N（N<=20）.接下来的N行中，第i行给出了第i个插座的位置坐标(xi,yi,zi);最后一行包含4个3元组（x1,y1,z1）…（x4,y4,z4）分别是长方形门框的4个角的三维坐标。4个数字全部为0表示全部测试结束，不要对该数据作任何处理。注意：这里假设长方体形状的房间完全位于三维坐标的第一象限，并且由一个角落在原点，地板位于X-Y平面。题目数据保证，每个插座仅属于四面墙中的一面，门上没有插座，每段电线的两端必须只能连接插座，电线不能交叉。

输出要求：对每一组测试，在一行里输出要将所有插座连通需要买的电线的最短整数长度。

一个不太靠谱的代码实现

这个代码正确性还有待校验，我们老师并没有给出测试数据😢

#include <iostream>
using namespace std;
int N;
const int max_N = 20;
const int MAX = 190;
double X = 5;//长宽高的默认值
double Y = 4;
double Z = 3;
struct outlet
{
    double x, y, z;
    int o;
}p[max_N], door[4];//定义20个容量存放插座，一个四个顶点的门
struct Way
{
    int u, v;
    double weight;
}way[MAX];//20个插座共有190条两两连接的线路
outlet temp;//门的上中心点

//先判断在哪个墙面
void whichwall(outlet* a)
{
    if (a->x == 0 && a->y != 0 && a->z != 0)
    {
        a->o = 2;
    }
    else if (a->x >= 0 && a->y == 0 && a->z >= 0)
    {
        a->o = 1;
    }
    else if (a->x != 0 && a->y >= 0 && a->z == 0)
    {
        a->o = 5;
    }
    else if (a->x == X)
    {
        a->o = 4;
    }
    else if (a->y == Y)
    {
        a->o = 3;
    }
    else if (a->z == Z)
    {
        a->o = 6;
    }
}
//根据在哪个墙面判断插座的相对位置
int whichrelation(outlet* a, outlet* b)
{
    whichwall(a); whichwall(b);
    if (a->o == b->o)
        return 1;//在同一面上
    else
    {
        int x = a->o > b->o ? a->o : b->o;
        int y = a->o < b->o ? a->o : b->o;
        if ((x == 6 && y == 5) || (x == 4 && y == 2) || (x == 3 && y == 1))
        {
            return 2;//在相对面上
        }
        else
        {
            return 3;//在相邻面上
        }
    }
}
//同一墙面插座线路是否绕门过(默认门四个顶点为左下0、左上1、右上2、右下3
int chuan(outlet a, outlet b)
{
    temp.x = (door[1].x + door[2].x) / 2;
    temp.y = (door[1].y + door[2].y) / 2;
    temp.z = (door[1].z + door[2].z) / 2;
    whichwall(&temp);
    if (a.z <= door[0].z || b.z <= door[0].z || a.z >= door[1].z || b.z >= door[1].z)
        return 0;//在门上方或下方过，不穿门
    else
    {
        if (temp.o == 1 && (a.x > door[2].x && b.x < door[1].x))
            return 1;
        else if (temp.o == 2 && (a.y < door[2].y && b.y > door[1].y))
            return 1;
        else if (temp.o == 3 && (a.x > door[2].x && b.x < door[1].x))
            return 1;
        else if (temp.o == 4 && (a.y > door[2].y && b.y < door[1].y))
            return 1;//在门两侧，穿门
        else
            return 0;
    }
}

//求最小值
double Min(double a, double b)
{
    return a < b ? a : b;
}

//同墙线路权值
double tongq(outlet* a, outlet* b)
{
    if (chuan(*a, *b) == 0)//不穿墙
        return fabs(a->x - b->x) + fabs(a->y - b->y) + fabs(a->z - b->z);
    else//穿墙
    {
        if (temp.o == 1 || temp.o == 3)
            return Min(fabs(a->x - b->x) + a->z + b->z, fabs(a->x - b->x) + fabs(a->z - temp.z) + fabs(b->z - temp.z));
        else
            return Min(fabs(a->y - b->y) + a->z + b->z, fabs(a->y - b->y) + fabs(a->z - temp.z) + fabs(b->z - temp.z));
    }
}
//对墙线路权值
double duiq(outlet* a, outlet* b)
{
    outlet* t; outlet* r;
    double m1, m2, m3;
    if (a->o == 1 || a->o == 3)//插座在1，3墙面上时
    {
        if (a->o == 3)
        {
            t = b;
            b = a;
            a = t;//交换后的a在1，b在3
        }
        if (temp.o == 1)//门在1墙上时
        {
            m1 = Y + a->z + b->z + fabs(a->x - b->x);//从地板过
            t = b; t->x = 0; t->y = 0;
            m2 = Y + b->x + tongq(t, a);//从2墙过
            t = b; t->x = X; t->y = 0;
            m3 = Y + (X - b->x) + tongq(t, a);//从4墙过
            m1 = Min(m1, m2);
            m1 = Min(m1, m3);
            return m1;
        }
        else if (temp.o == 2)
        {
            m1 = Y + a->z + b->z + fabs(a->x - b->x);//从地板过
            t = a; r = b;
            t->x = 0; r->x = 0;
            m2 = a->x + b->x + tongq(t, r);//从2墙过
            t->x = X; r->x = X;
            m3 = Y + X - a->x + X - b->x + fabs(a->z - b->z);//从4墙过
            m1 = Min(m1, m2);
            m1 = Min(m1, m3);
            return m1;
        }
        else if (temp.o == 3)
        {
            m1 = Y + a->z + b->z + fabs(a->x - b->x);
            t = a; t->x = 0; t->y = Y;
            m2 = Y + a->x + tongq(t, b);
            t = a; t->x = X; t->y = Y;
            m3 = Y + (X - a->x) + tongq(t, b);
            m1 = Min(m1, m2);//同上，三种情况
            m1 = Min(m1, m3);
            return m1;
        }
        else
        {
            m1 = Y + a->z + b->z + fabs(a->x - b->x);
            m2 = Y + a->x + b->x + fabs(a->z - b->z);
            t = a; r = b;
            t->x = 5; r->x = 5;
            m3 = X - a->x + X - b->x + tongq(t, r);
            m1 = Min(m1, m2);//同上，三种情况
            m1 = Min(m1, m3);
            return m1;
        }
    }
    if (a->o == 2 || a->o == 4)//插座在2,4墙面上时
    {
        if (a->o == 4)
        {
            t = b;
            b = a;
            a = t;//交换后的a在2，b在4
        }
        if (temp.o == 1)
        {
            m1 = X + a->z + b->z + fabs(a->y - b->y);//从地板过
            t = a; r = b;
            t->y = 0; r->y = 0;
            m2 = a->y + b->y + tongq(t, r);//从1墙过
            m3 = X + Y - a->y + Y - b->y + fabs(a->z - b->z);//从4墙过
            m1 = Min(m1, m2);
            m1 = Min(m1, m3);
            return m1;
        }
        else if (temp.o == 2)
        {
            m1 = X + a->z + b->z + fabs(a->y - b->y);
            t = b; t->y = 0; t->x = 0;
            m2 = X + b->y + tongq(t, a);
            t->y = Y;
            m3 = X + Y - b->y + tongq(t, a);
            m1 = Min(m1, m2);
            m1 = Min(m1, m3);
            return m1;
        }
        else if (temp.o == 3)
        {
            m1 = X + a->z + b->z + fabs(a->y - b->y);
            m2 = X + a->y + b->y + fabs(a->z - b->z);
            t = a; r = b;
            t->y = Y; r->y = Y;
            m3 = Y - a->y + Y - b->y + tongq(t, r);
            m1 = Min(m1, m2);
            m1 = Min(m1, m3);
            return m1;
        }
        else
        {
            m1 = X + a->z + b->z + fabs(a->y - b->y);
            t = a; t->x = X; t->y = 0;
            m2 = X + a->y + tongq(t, b);
            t->y = Y;
            m3 = X + Y - a->y + tongq(t, b);
            m1 = Min(m1, m2);
            m1 = Min(m1, m3);
            return m1;
        }
    }
}
//邻墙两插座线路权值
double linq(outlet* a, outlet* b)
{
    outlet* t = a;//在两墙面的共线上找一个点，与a或b同高，转化为两个同墙问题
    if ((a->o == 1 && b->o == 2) || (a->o == 2 && b->o == 1))
    {
        t->x = 0; t->y = 0;
        return tongq(t, a) + tongq(t, b);
    }
    else if ((a->o == 2 && b->o == 3) || (a->o == 3 && b->o == 2))
    {
        t->x = 0; t->y = Y;
        return tongq(t, a) + tongq(t, b);
    }
    else if ((a->o == 3 && b->o == 4) || a->o == 4 && b->o == 3)
    {
        t->x = X; t->y = Y;
        return tongq(t, a) + tongq(t, b);
    }
    else
    {
        t->x = X; t->y = 0;
        return tongq(t, a) + tongq(t, b);
    }
}
//根据插座的相对位置计算权值
double calculate(outlet* a, outlet* b)
{

    switch (whichrelation(a, b))
    {
    case 1:
        return tongq(a, b); break;
    case 2:
        return duiq(a, b); break;
    case 3:
        return linq(a, b); break;
    default:
        return -1; break;
    }
}
//所有插座两两计算线路权值(长度
void quan()
{
    int k = 0;
    for (int i = 0; i < N - 1; i++)
    {
        for (int j = i + 1; j < N; j++)
        {
            if (calculate(p + i, p + j) == -1)
                cout << "problem";
            way[k].weight = calculate(p + i, p + j);
            way[k].u = i;
            way[k].v = j;
            k++;
        }
    }
}
//按权值大小排序线路
void sort_way(int left, int right)
{
    int i = left;
    int j = right;
    Way t = way[left];
    if (left > right)
        return;//排序结束
    while (i != j)
    {
        while (way[j].weight >= t.weight && j > i)
        {
            j--;
        }
        if (j > i)
        {
            way[i] = way[j];
            i++;
        }
        while (way[i].weight <= t.weight && j > i)
        {
            i++;
        }
        if (j > i)
        {
            way[j] = way[i];
            j--;
        }
    }
    way[i] = t;
    sort_way(left, i - 1);
    sort_way(i + 1, right);
}
//克鲁斯卡尔算法求总线路长
double kruskal()
{
    quan();//先求权值
    int n = N * (N - 1) / 2;
    sort_way(0,n-1);//再排序
    int vexset[max_N] = {0};
    double sum = 0;
    for (int i = 0; i < N; i++)
    {
        vexset[i] = i;//给每个插座赋值连通分量
    }
    for (int i = 0; i < n; i++)
    {
        int v1 = way[i].u;
        int v2 = way[i].v;
        int vs1 = vexset[v1];
        int vs2 = vexset[v2];
        if (vs1 != vs2)//从短到长，若最短的线路与已经连好的线路不构成环路，则采用
        {
            for (int j = 0; j < N; j++)
            {
                if (vexset[j] == vs2)
                    vexset[j] = vs1;
            }
            sum += way[i].weight;
        }//直到其他所有线路都与已经连接的线路构成环路，说明最小生成树已经完成
    }
    return sum;
}
int main()
{
    while (cin >> X >> Y >> Z >> N)
    {
        if (!X && !Y && !Z && !N) break;
        cout << "输入以初始化插座和门：" << endl;
        for (int i = 0; i < N; i++)
            cin >> p[i].x >> p[i].y >> p[i].z;
        for (int i = 0; i < 4; i++)
            cin >> door[i].x >> door[i].y >> door[i].z;
        
        double sum = kruskal();
        cout << "需要买的电线最短长度为：";
        if (sum > int(sum))
            cout << int(sum + 1) << endl;
        else
            cout << sum << endl;
    }
    cout << "程序结束";
}

**本次课设参考了大佬的做法，出处：http://blog.csdn.net/lttree

**还有在写排序算法时参考了快速排序算法，出处：http://t.csdn.cn/BoEKm