「1038」Recover the Smallest Number

Given a collection of number segments, you are supposed to recover the smallest number from them. For example, given { 32, 321, 3214, 0229, 87 }, we can recover many numbers such like 32-321-3214-0229-87 or 0229-32-87-321-3214 with respect to different orders of combinations of these segments, and the smallest number is 0229-321-3214-32-87.

Input Specification:

Each input file contains one test case. Each case gives a positive integer N ( ) followed by N number segments. Each segment contains a non-negative integer of no more than 8 digits. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print the smallest number in one line. Notice that the first digit must not be zero.

Sample Input:

5 32 321 3214 0229 87

Sample Output:

22932132143287

---

Ω

有点意思，给出几个长度不一的数字切片，希望你重组为一个最小的数。

刚开始没想到贪心算法，总是想着全部读入然后构建一棵排序树，但处理起来总是相对麻烦。后来突然灵光一现，完全可以一边读入一边排序，找到适当的位置插入后成为当前最小的数字，这是很经典的贪心算法。

那么如何证明这个贪心算法得出的结果一定是题目所求呢。我们只需证明每一次的最优解能通过排序插入的方式找到下一次的最优解即可。如果对于一个最小排列，我们随机从中抽走一个切片后的结果不是最小排列，那么我们一定能够将抽走的切片与剩余切片的最小排列构造出一个比原排列更小的新排列，矛盾。这说明所有最小排列都可拆分成一个切片和另一个最小排列，从而归纳证明了贪心的正确性。

排序插入的流程是从当前最左边的切片开始比较放置在前面和后面的大小，若放置在前面更小则停止比较并将其插入到该切片的前面，否则继续与下一个切片进行比较。之所以可以这么比较是因为当前的切片序列也是有序的，而这种比较方式类似于冒泡排序。

众所周知，排序冒泡在排列逆序数据时会耗时巨大，这也导致最后一个测试点无法通过。由于是在有序切片内进行插入，因此可以采取二分的方式。但更为简便的方式是采用<algorithm>库中的sort函数，指定cmp函数为return a+b<b+a;。

最后需要找到第一个非零数字，注意前面的0不要输出，另外别忘了全0大坑。

---

C ☺ D E

➢ 二分法

#include <iostream>
#include <vector>

using namespace std;
char r[10];

int main()
{
    int n;
    cin >> n;
    string s;
    vector<string> arrange;
    for (int i = 0; i < n; ++i)
    {
        scanf("%s", r);
        s = r;
        if (i == 0)
            arrange.push_back(s);
        else
        {
            string x, y;
            int left = 0, right = arrange.size();
            while (left < right)
            {
                int mid = (left + right) / 2;
                x = s + arrange[mid];
                y = arrange[mid] + s;
                if (x > y)
                    left = mid + 1;
                else
                    right = mid;
            }
            arrange.insert(arrange.begin() + left, s);
        }
    }

    bool flag = false;

    for (auto &k: arrange)
    {
        if (flag)
            printf("%s", k.c_str());
        else
        {
            flag = !(k == string(k.size(), '0')) || flag;
            for (int i = 0; i < k.size(); ++i)
                if (k[i] != '0')
                {
                    printf("%s", k.substr(i, k.size() - i).c_str());
                    break;
                }
        }
    }
    if (!flag)
        printf("0");
}

➣ sort

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    int n;
    cin >> n;
    vector<string> arrange(n);
    for (int i = 0; i < n; ++i)
        cin >> arrange[i];

    sort(arrange.begin(), arrange.end(), [](string &a, string &b) { return a + b < b + a; });

    bool flag = false;
    for (auto &k: arrange)
    {
        if (flag)
            printf("%s", k.c_str());
        else
        {
            flag = !(k == string(k.size(), '0')) || flag;
            for (int i = 0; i < k.size(); ++i)
                if (k[i] != '0')
                {
                    printf("%s", k.substr(i, k.size() - i).c_str());
                    break;
                }
        }
    }
    if (!flag)
        printf("0");
}