小于n的最大数 - 贪心算法 - 附C++实现代码

一、问题描述？

        给定一个整数n，并从1~9中给定若干个可以使用的数字，根据上述两个条件，得到每一位都为给定可使用数字的、最大的小于整数n的数。

        例如，给定可以使用的数字为 {2,3,8} 三个数：

        给定 n=3589，输出3388；给定 n=8234，输出8233；…… 

二、解题思路

1.问题分析

        如果一个数小于另一个数，那么较小的那个数一定有至少一个数量级的位是小于大数的。而为了取到小于n又尽可能大的值，我们总是希望能够在数量级尽可能小的位置小于n。

        假定可以使用的数字为 {2,3,8} ，在尝试过程中，我们可以发现，结果有以下几类：

        1> 高位相等，最后一位取到了小于的值。例如：给定 n=8234，除最后一位外，我们都能够取到相等的值，最后一位也刚好能够取到一个小于n个位的值，输出8233；

        2> 高位相等，中间一位取到了小于的值。例如：给定 n=8534，在第二位，我们已经只能取到小于n的数了，此时，数量级更小的位也随之确定，均为给定的最大数字，输出8388；

        3> 在高位就已经无法相等，但最高位能取到更小的值。这种情况相当于第二种情况的高位位数退化到0。例如：给定 n=5555，将会输出3333；

        4> 在高位就已经无法相等，且最高位也无法取到更小的值。此时，与n相同的数量级内已经不存在解，我们向下一个数量级输出最大的位数。例如：给定 n=1999，将会输出888；

2.算法选择

        从上面的分析中不难看出，我们总是寄希望于在数量级尽可能小的位里才使我们的结果小于n，对应的，尝试使用贪心算法+回溯来求解这个问题。

3.运算示例

        给定可以使用的数字为 {2,3,8}：

        n1 = 2338，贪心，从高往低取：2 - 3 - 3 - ；此时到达最后一位，尝试取更小的，- 3；

        n2 = 2399，贪心，从高往低取：2 - 3 - ；此时只能取更小的，- 8；剩余位数均为 - 8；

        n3 = 2381，贪心，从高往低取：2 - 3 - 8 - ；此时无法取更小的，回溯，上一位能取到更小值，改 - 8 为 -3，后接max值：2 - 3 - 3 - 8；

        n4 = 1999，贪心，最高位就无法取更小的，此时已经无需回溯也无法回溯，直接确认为少一数量级（第六段中有相关番外），得到8 - 8 - 8；

        n5 = 2222，贪心，从高往低取：2 - 2 - 2 - ；此时到达最后一位，必须取更小值，已经无法取得，回溯，上一位无法取到更小值，继续回溯，仍无法取得更小值，继续回溯，无法取得，此时已经到达首位，无法再回溯，到此时，确认为少一个数量级，得到8 - 8 - 8；

4.数据结构

        1>功能：记录给定数字；                                           对应结构：vector；

        2>功能：记录结果；                                                   对应结构：vector；

        3>功能：拆分给定 n 并记录；                                    对应结构：vector；

        4>功能：从给定数字集中快速查找目标是否存在；    对应结构：map ：unordered_set；

三、伪代码与接口

//-----接口1-----//
//@brief  : 从给定的集合中获取小于指定值的数
//@param  : 一个已经从大到小排序的集合, 指定值
//@return : 若集合中存在合法结果，返回给定值；否则返回0；
int getMaxDigitLessThanGivenDigit(const vector<int>& digits, int d) {
    //从大到小遍历
    {
        //若找到小于指定值的数，返回该数
    }
    //若遍历无结果，返回0
}

//-----接口2-----//
//@brief  : 从给定的集合中获取小于指定值的数
//@param  : 一个已经从大到小排序的集合, 指定值
//@return : 若集合中存在合法结果，返回给定值；否则返回0；
int getMaxNumLessThanGivenN(vector<int>& digits, int n) {
    //拆分n为单位数形式

    //排序给定值

    //定义vector格式结果

    //构建快速查找map

    //从高位往低位遍历n，根据遍历到的每一位，尝试确定结果
    {
        //对非最高位，首先尝试给定集合中是否能取到相同值
        {
            //若能取到相同值，先将结果中相同位贪心为相同值，然后继续查找下一位
        }

        //若不能取到相同值，调用接口1尝试是否能取到较小值
        {
            //若能取到较小值，赋值该位为较小值，接着后续位数均为给定值中的最大值，跳出遍历
        }

        //若不能取到较小值，需要回溯
        //若已经是最高位，无法进行回溯
        {
            //定义结果为小一数量级，跳出遍历
        }

        //进行回溯，向高一位移动
        {
            //每次回溯，先将旧结果（失效值）抹去
            
            //此时只能找较小值（相等值已经贪心过了），调用接口1尝试回溯位是否能取到较小值
            {
                //若能取到较小值，赋值该位为较小值，接着后续位数均为给定值中的最大值，跳出遍历
            }

            //若已经回溯到了最高位，仍未找到较小值，此时可以断定需要减少一个数量级
            {
                //定义结果为小一数量级，跳出遍历
            }
        }

        //若回溯已经执行完但仍执行到了这里，强制跳出遍历，否则会发生死循环（指针在高低位往返移动）
    }

    //转换单位数格式的结果为数据的结果，返回
}

//-----main-----//
//@brief  : 调用接口2并传参
//@param  : 
//@output : 输出结果
//@return : 

四、C++代码

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

using namespace std;

//Get max digit which is less than d from given digits which is sorted from big to small.
int getMaxDigitLessThanGivenDigit(const vector<int>& digits, int d) {
    for (auto it = digits.rbegin(); it < digits.rend(); it++) {   //Searching from big to small.
        if (*it < d) {   //The first one to be less than d is the max one among the less set.
            return *it;
        }
    }
    //If miss, return 0;
    return 0;
}

//Get max num consisted of digits in vector digits. The num is expected to be less than n.
int getMaxNumLessThanGivenN(vector<int>& digits, int n) {
    //-----Condition due and result delare.-----//
    //Devide n into digits.
    vector<int> n_digits;
    for (; n > 0; n /= 10)
        n_digits.push_back(n % 10);

    //Sort given digits.
    sort(digits.begin(), digits.end());

    //Declare target digits. Format {0,0,...,0}. Target format is {0,0,...,0,1,2,3}. At the end, 0 will be replace by max digit given.
    vector<int> t_digits(n_digits.size(), 0);

    //-----Construct auxiliary variable.-----//
    //Make map for fast consistence judge.
    unordered_set<int> set;
    for (auto di : digits)
        set.insert(di);

    //Begin to fill target digits. From high to low.
    for (int i = n_digits.size() - 1; i >= 0; i--) {
        //Case 1 : For those who are not highest, chioce the same num if exists.
        if (i > 0 && set.count(n_digits[i])) {  //Exist.
            t_digits[i] = n_digits[i];  //This digit use it temp, continue to go through.
            continue;
        }

        //Case 2 : If not exist same num, try to get max digit which is less than n's current digit.
        int less_d = getMaxDigitLessThanGivenDigit(digits, n_digits[i]);

        //If got one num less than n's current digit, the reslt will be sure and there is no need to continue traverse.
        if (less_d > 0) {
            t_digits[i] = less_d;
            break;   //Format {0,0,...,0,1,2,3}. 0 is excepted to be replaced by max digit given.
        }

        //Case 3 : If there is no digit less than n's current digit, flash back.
        //-----Boundary condition : include Method 1 and Method 2, only use one.-----//
        //Method 1 : if hightest, directly resize.
        if (i == n_digits.size() - 1) {
            t_digits.resize(i);
            break;
        }
        //Method 2 : move cursor only not in hightest. If not highest, move back the cursor.
        else {
            i++;
        }

        for (; i < n_digits.size(); i++) {
            //If the digit is flashed back, corresponding t_digits need to be clear. Reassign it 0.
            t_digits[i] = 0;

            //Try to be smaller while flashing back. Turn to case 2.
            less_d = getMaxDigitLessThanGivenDigit(digits, n_digits[i]);
            if (less_d > 0) {
                t_digits[i] = less_d;
                break;   //Format {0,0,...,0,1,2,3}. 0 is excepted to be replaced by max digit given.
            }

            //If fail to lessen this digit but this digit isn't the highest, just continue to flash back.

            //But if this digit is the highest, it means there are no answer in the same order of magnitude.
            if (i == n_digits.size() - 1)
                t_digits.resize(i);
        }

        //If Case 3 finished, the result has been sure here. Stop. Otherwise endless looping will happen.
        break;
    }

    //Turn target from digit format to num format.
    int target = 0;

    //From high to low, replace 0 to max.
    for (int t_d = t_digits.size() - 1; t_d >= 0; t_d--)
        target = 10 * target + (t_digits[t_d] == 0 ? digits.back() : t_digits[t_d]);

    return target;
}

int main()
{
    cout << "Testing begin..." << endl;

    //Unordered for sort test.
    vector<int> digits = { 2,8,3 };
    cout << "Given digits is:  ";
    for (auto it : digits)
        cout << it << "   ";
    cout << endl;

    //Case 1 : Smaller in last, same the head. Can be same but avoid. n = 2338.
    cout << "n = 2338   excepted output : 2333   actually output : " << getMaxNumLessThanGivenN(digits, 2338) << endl;

    //Case 2 : Smaller in last, same the head. Get smaller. n = 2339.
    cout << "n = 2339   excepted output : 2338   actually output : " << getMaxNumLessThanGivenN(digits, 2339) << endl;

    //Case 3 : Smaller in middle, same the head, tail the max, no need to flash back. n = 2349.
    cout << "n = 2399   excepted output : 2388   actually output : " << getMaxNumLessThanGivenN(digits, 2399) << endl;

    //Case 4 : Smaller in middle, same the head, tail the max, need to flash back. n = 2381.
    cout << "n = 2381   excepted output : 2338   actually output : " << getMaxNumLessThanGivenN(digits, 2381) << endl;

    //Case 5 : Smaller in order, no need to flash back. Fail in head. n = 1999.
    cout << "n = 1999   excepted output : 888    actually output : " << getMaxNumLessThanGivenN(digits, 1999) << endl;

    //Case 6 : Smaller in order, need to flash back. Fail not in head. n = 2221.
    cout << "n = 2221   excepted output : 888    actually output : " << getMaxNumLessThanGivenN(digits, 2221) << endl;

    //Case 7 : Smaller in order, need to flash back. Special test. n = 2222.
    cout << "n = 2222   excepted output : 888    actually output : " << getMaxNumLessThanGivenN(digits, 2222) << endl;

    return 0;
}

五、测试结果

        根据对应的几种可能情况进行测试：

六、番外：测试中发现缺少边界条件与查错

        第一次调试时，回溯漏了边界条件的判定，只要发生回溯，就直接把指针指往上一位，对应的C++代码段为：for (i++; i < n_digits.size(); i++)，缺少了“若已经是最高位，无法进行回溯”的边界条件。这样一来，当最高位就确定出结果为减数量级情况时，无法唤起 resize，导致边界条件出错：

        检查后做了对应的边界限制，若第一位就直接唤起回溯时不会移动指针，而是直接确认结果。