编程之美 - 爬楼梯问题

问题： 电梯在高峰时为了提高效率，当人们进入电梯选择好楼层后，根据算法只停在其中的一层。这个算法要求电梯里所有的人爬楼梯的总数最少。

想法 I：算是穷举法吧，把每个人可能会爬的楼层数都计算出来，然后逐一求和后，再找出和最小的值。

假设有10层楼，5个人分别到3，6，9，10，5 层，穷举一下可以得到

2  5  8  9  4   = 28         停在第 1   层爬楼的总数

1  4  7  8  3   = 23         停在第 2   层爬楼的总数

0  3  6  7  2   = 18         停在第 3   层爬楼的总数

1  2  5  6  1   = 15         停在第 4   层爬楼的总数

2  1  4  5  0   = 12         停在第 5   层爬楼的总数

3  0  3  4  1   = 11         停在第 6   层爬楼的总数

4  1  2  3  2   = 12         停在第 7   层爬楼的总数

5  2  1  2  3   = 13         停在第 8   层爬楼的总数

6  3  0  1  4   = 14         停在第 9   层爬楼的总数

7  4  1  0  5   = 17        停在第 10 层爬楼的总数

这里可以看出：到第6层停是可以满足要求的。

代码：测试 假设一共有5个人分别去 3，6，9，10和5层

#include <iostream>

using namespace std;

#define PEOPLE    5
#define FLOORS    10
#define MAX       50

int arrTarget[PEOPLE] = {3,6,9,10,5};
int arrResult[FLOORS][PEOPLE];
int arrClmib[FLOORS];

void print(int arr[FLOORS][PEOPLE])
{
    int i = 0, j = 0;
    for (i = 0; i < FLOORS; i++)
    {
        for(j = 0; j < PEOPLE;j++)
        {
            cout << arrResult[i][j] << "  ";
        }
        cout << " = " << arrClmib[i]<< endl;
    }
}

void scan()
{
    int i = 0, j = 0;
    int nMin = MAX, nMinIndex = 0; 
    memset(arrResult, -1, sizeof(int)*PEOPLE*FLOORS);

    for (i = 0; i < FLOORS; i++)
    {
        for(j = 0; j < PEOPLE;j++)
        {
            arrResult[i][j] = abs(i+1 - arrTarget[j]);
            arrClmib[i] += arrResult[i][j];
        }
        if (nMin > arrClmib[i])
        {
            nMin = arrClmib[i];
            nMinIndex = i;
        }
    }

    print(arrResult);
    cout << "\n========================================" << endl;
    cout << "stop at: floor " << nMinIndex+1 << "   clmib = " << nMin << endl;
}

void main()
{
    int i = 0;

    scan();

    cin >> i;
}

测试结果：

2  5  8  9  4   = 28

1  4  7  8  3   = 23

0  3  6  7  2   = 18

1  2  5  6  1   = 15

2  1  4  5  0   = 12

3  0  3  4  1   = 11

4  1  2  3  2   = 12

5  2  1  2  3   = 13

6  3  0  1  4   = 14

7  4  1  0  5   = 17

========================================

stop at: floor 6   clmib = 11

复杂度为 O(N*N)

想法 II： 利用你多爬一层我就少爬一层的关系，找一个最优的解。

假设就三层楼 i-1,  i,  i+1，到i-1层总共会爬N1层，到i层会爬N2，到 i+1会爬N3

如果电梯停在i-1层，那么也就有N1层的楼不用爬了。总数也就 Y -N1+N2+N3

如果电梯停在i+1层，那么也就有N3层的楼不用爬了。总数也就 Y+N1+N2 -N3

如果N1 > N2+N3那一定是停在i-1层合适，减去的楼层多了

如果N3 > N1+N2那一定是停在i+1层合适，减去的楼层多了

这样得到了算法II，先算出所有的要爬的楼层的总和，在按上面的计算方式每层向上计算。

代码：测试  假设一共有5个人分别去 3，6，9，10和5层

这里arrFloorPeople的数字表示到每一层的人数。

#include <iostream>

using namespace std;

#define FLOORS    10
int arrFloorPeople[FLOORS] = {0,0,1,0,1,1,0,0,1,1};

void Calc(int &nFloors, int& nFloorIndex)
{
    int i = 0;
    int N1 =0, N2 = 0, N3 = 0;
    int nMin = 0, nTargetFloor = 0;

    for (N1 = 0, N2 = arrFloorPeople[1], N3 = 0, i = 1; i < FLOORS; i++)
    {
        N3 += arrFloorPeople[i];
        nMin += arrFloorPeople[i] * (i-1);
    }

    for (i = 2; i < FLOORS; i++)
    {
        if(N1+N2 <N3)
        {
            nTargetFloor = i;
            nMin += (N1 + N2 - N3);
            N1 += N2;
            N2 = arrFloorPeople[i];
            N3 -= arrFloorPeople[i];
        }
        else
            break;
    }
    nFloors = nMin;
    nFloorIndex = nTargetFloor+1;
}

void main()
{
    int nFloors = 0; 
    int nFloorIndex = 0;

    Calc(nFloors, nFloorIndex);
    cout << "stop at: floor " << nFloorIndex << "   clmib = " << nFloors << endl;
    cin >> nFloors;
}

测试结果：

stop at: floor 6   clmib = 11

复杂度为 O(N)