《数据结构与算法分析：C语言描述》复习——第十章“算法设计技巧”——收费站重建问题

2014.07.07 18:19

简介：

　　给定一条数轴上的n个互不重合的点，你可以计算出C(n,2)=n(n-1)/2个距离。如果我给你这些距离值，你能反推出这n个点的坐标吗？

描述：

　　首先，考虑到你可以平移这n个点，并且可以左右反转它们得到对称的两种情况，我们不妨假设最靠左的点p₀的坐标正好是0。

　　

　　接下来我们通过深度优先搜索和回溯的手段逐个求出每个点的坐标。

　　起初我们有n(n-1)/2个距离，搜索要如何下手呢？从最长的那个下手。

　　比如n=3时，有距离之{3,7,10}。这其中，10能够告诉我们最靠右的点p₂坐标一定10，因为两端的两点离得最远。

　　由此我们一开始就能够确定两个端点的坐标p₀（人为规定为0）和p_n-1，接下来中间的n-2个点需要通过搜索来确定。

　　

　　假设你现在已经确定了i个点的坐标，剩余的距离集合是D_余（想想当你确定了i个点之后，手里剩下还有多少个距离）。初始的距离集合D_全拥有n(n-1)/2个距离。

　　如果目前D_余中最大的距离是d=max(D_余)，那么第i+1个点的坐标可能是d或者p_n-1-d。

　　

　　这样产生了两种可能性，对于每一种可能性，你都要第i+1个点与前i个点的距离是否能在D余中找到。

　　如果D余中找不到对应的距离值，说明这次搜索已经失败，需要回溯到上层。

　　而如果这i次检验全部成功的话，需要从D_余中去掉i个距离值。

　　

　　这个搜索与回溯的过程说起来容易，但如果你真的用简单的数组作为数据结构，会发现操作很不方便而且效率低下。

　　我们有如下三点需求：

　　　　1. 找出D_余中最长的边，我需要有序的数据

　　　　2. 查找某个距离值d是否在D_余中，我需要快速查找（至少不是线性查找）

　　　　3. 回溯时我需要把去掉过的距离值重新放回D_余中，我需要快速插入（向数组中间插入元素，效率无法忍受）

　　基于以上三点需求，平衡树成了最佳选择。于是STL的<map>成为解决这个问题的上佳工具。（begin()与rbegin()有何用处？）

　　就算你执意用简单的数组解决这个问题，觉得那样可以偷懒，实际写起来还是既繁琐又低效。（因为往数组中间插入或删除东西实在是很不和谐的操作）

　　说到时间复杂度，这种搜索+回溯的解法自然是指数级的。

　　也许用八皇后问题来作为回溯的例子更容易些，不过既然作者选了这个我们就学这个吧。

实现：

// Turnpike reconstruction problem.
//    Description:
//        Given n * (n - 1) / 2 distances, find out if you can determine the 
//            relative coordinates of n points.
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>
using namespace std;

int myabs(int x)
{
    return x > 0 ? x : -x;
}

bool turnpikeReconstruction(int idx, vector<int> &x, map<int, int> &dist_set, 
    const int far)
{
    if (idx == 0) {
        return true;
    }
    
    int cur_n;
    int cur_far;
    int i;
    map<int, int>::iterator it;
    
    cur_n = (int)x.size();
    cur_far = dist_set.rbegin()->first;
    for (i = 0; i < cur_n; ++i) {
        it = dist_set.find(myabs(cur_far - x[i]));
        if (it == dist_set.end() || it->second == 0) {
            break;
        }
        --it->second;
        if (it->second == 0) {
            dist_set.erase(it);
        }
    }
    if (i == cur_n) {
        x.push_back(cur_far);
        if (turnpikeReconstruction(idx - 1, x, dist_set, far)) {
            return true;
        }
        x.pop_back();
    }
    cur_n = i;
    for (i = 0; i < cur_n; ++i) {
        ++dist_set[myabs(cur_far - x[i])];
    }
    
    cur_n = (int)x.size();
    cur_far = dist_set.rbegin()->first;
    for (i = 0; i < cur_n; ++i) {
        it = dist_set.find(myabs(far - cur_far - x[i]));
        if (it == dist_set.end() || it->second == 0) {
            break;
        }
        --it->second;
        if (it->second == 0) {
            dist_set.erase(it);
        }
    }
    if (i == cur_n) {
        x.push_back(far - cur_far);
        if (turnpikeReconstruction(idx - 1, x, dist_set, far)) {
            return true;
        }
        x.pop_back();
    }
    cur_n = i;
    for (i = 0; i < cur_n; ++i) {
        ++dist_set[myabs(far - cur_far - x[i])];
    }
    
    return false;
}

int main()
{
    int i;
    int n, n2;
    vector<int> x;
    int dist;
    map<int, int> dist_set;
    int far;
    
    while (cin >> n2 && n2 > 0) {
        for (i = 0; i < n2; ++i) {
            cin >> dist;
            ++dist_set[dist];
        }
        n = (int)sqrt(n2 * 2.0) + 1;
        far = dist_set.rbegin()->first;
        --dist_set[far];
        if (dist_set.rbegin()->second == 0) {
            dist_set.erase(far);
        }
        
        x.push_back(0);
        x.push_back(far);
        if (!turnpikeReconstruction(n - 2, x, dist_set, far)) {
            cout << "No solution." << endl;
        } else {
            sort(x.begin(), x.end());
            for (i = 0; i < n; ++i) {
                cout << x[i] << ' ';
            }
            cout << endl;
        }
        
        x.clear();
        dist_set.clear();
    }
    
    return 0;
}