Leo的幸运数字——算法笔记

本文链接：https://blog.csdn.net/weixin_43207025/article/details/90373090

题目描述：

Leo最近在练习万以内的加减法，因为她在路上捡到了一本册子，上面写着：
给一个四位数a，把它的四位数字重新排序后，字典序最大减去字典序最小，得到数字b，称为一次幸运操作，如果对于任意数字和任意操作次数都能快速算出来，那么高考就能考数学满分。
例如，对于9899进行两次幸运操作，则9998-8999=999 9990-0999=8991，最后得到8991这个数字。
Leo数学还是不太好，所以请你帮她计算每一组数字a进行n次幸运操作后得到的数字。
(由于四位相同时，相减得0，所以数据保证a的四位不全相同）

输入：

第一行为数字t，表示有t组数据（ t <=100000）
接下来的t行，每行两个整数，a和n （1000<a<9999 0<n<=100000）

输出：

对于每组数据，输出一行数字，表示该组数据最后得到的数字。（不需输出前导0）

输入样例：

2
9998 1
9998 2

输出样例：

999
8991

解题思路：

题目解决起来很简单，但是这题是要优化算法以减少时间复杂度，不然是不会通过的。
然而，这个题其实是 6174 猜想，即所有四位不全相同的四位数这么操作至多 7 次以后，必定得到 6174，而 6174 操作后得到本身，所以这题判断到重复即输出即可，不会超时。
但是，这个判断重复也是有技巧的。可能也会走一些冤枉路，最终还是超时。比如说我最开始的想法：直接把 n >= 7 的数据输出 6174。其他的再进行一步步的计算。发现有些数据不会到 7 次就输出了6174。所以时间复杂度不到要求。之后，我又改进这个思路：这次我在每次计算过程中把排好序的数组合6174进行逐一对比，若相同则跳出。但是结果还是超时。

这个超时的代码如下：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

bool cmp (int a, int b)
{
    return a > b;
}


void fenli (int *a, int b)
{
    a[1] = b / 1000;
    a[2] = b % 1000 / 100;
    a[3] = b % 100 / 10;
    a[4] = b % 10;
}

int zuhe_max (int *k)
{
    int maxn = k[1] * 1000 + k[2] * 100 + k[3] * 10 + k[4];
    return maxn;
}

int  zuhe_min (int *k)
{
    int minn = k[4] * 1000 + k[3] * 100 + k[2] * 10 + k[1];
    return minn;
}

int main()
{
    int t;
    scanf ("%d", &t);
    while (t--)
    {
        int m, n;
        int a[5];
        int result, maxn, minn;
        cin >> m >> n;
        fenli (a, m);
        for (int i = 1; i <= n; i++)
        {
            sort (a + 1, a + 5, cmp); //从大到小
            if (a[1] == 7 && a[2] == 6 && a[3] == 4 && a[4] == 1)  //判断计算过程中是否出现了6174
            {
                result = 6174;
                break;
            }
            maxn = zuhe_max (a);

            minn = zuhe_min (a);

            result = maxn - minn;
            fenli (a, result);
        }
        printf ("%d\n", result);

    }
}

结果，判断结果还是超时，而且比以前那个 n >= 7输出还多一点。我是真的不知道怎么改了。于是就转换一种思路，得到了与之差不多相同的算法，然后就通过了。

通过的代码参考：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

int zuhe_min (char *k)
{
    int minn = (k[0] - '0') * 1000 + (k[1] - '0') * 100 + (k[2] - '0') * 10 + (k[3] - '0');
    return minn;
}

int  zuhe_max (char *k)
{
    int maxn = (k[3] - '0') * 1000 + (k[2] - '0') * 100 + (k[1] - '0') * 10 + (k[0] - '0');
    return maxn;
}


int main()
{
    int t;
    cin>>t;
    while (t--)
    {
        char a[5];
        int result, maxn, minn;
        scanf("%s", a);
        int n, index = 0;
        scanf("%d", &n);

        for (int i = 1; i <= n; i++)
        {
            sort(a, a + 4); //从小到大

            maxn = zuhe_max (a);    //求出最大组合值

            minn = zuhe_min (a);    //求出最小组合值

            result = maxn - minn;

            if (result == index)    // 这三个语句用来判断是否已经出现了6174这个值，
                break;              // 如果出现过，会保留在 index 中，则下一次运行到这里就会直接跳出循环;那么以后的就不需要执行了。
            index = result;         // 若是设阈值>=7时输出6174，还是会超时14%，是因为对于一些个别数据，有可能不需要计算七次就出现6174.
                                    //因此，在计算过程中应设置一旦出现6174就停止，又会减少时间。

            for (int j = 0; j < 4; j++) //分离各位
            {
                a[j] = result % 10;
                result = result / 10;
            }
        }
        printf("%d\n", index);

    }
}