小明认为某些数字不吉利，付账时会尽可能少的多付一些钱，使得价

def getLuckyPrice(price,unlucky_numbers):
    p = list(map(int,' '.join(str(price)).split()))
    p.insert(0,0) # 在首位增加一位，以防止价格首位为9而9也是不幸运数字
    for i in range(len(p)-1,0,-1):
        helper(i,p,unlucky_numbers) # 改变价格以变成幸运数字
    if p[0] == 0: # 如果未进位，不输入0
        print(p[1:]) 
    else:
        helper(0,p,unlucky_numbers) # 如果进位，也要判断进位后的1是不是属于不幸运数字
        print(p)
    
    
def helper(i,p,unlucky_numbers):
    if p[i] in unlucky_numbers or p[i] == 0:
        for j in range(len(unlucky_numbers)):
            if p[i] == unlucky_numbers[j] or p[i] == 0:
                p[i] = p[i]+1
#             else:
#                 continue
            if p[i] >= 10:
                p[i] = p[i] % 10
                p[i-1] = p[i-1]+1
            helper(i,p,unlucky_numbers) # 递归判断增加1后的数字还属不属于不幸运数字
#             else:
#                 continue

# 测试
getLuckyPrice(9009,[1,4,7,9])
getLuckyPrice(1000,[1,4,7,8])
         

        int getLuckyPrice(int price, List<Integer> unlucky_numbers){
        
        //price的每一位
        int[] array = new int[10];
        int i = 0;
        //最后结果
        int res = 0;
        while(price > 0){
            array[i] = price % 10;
            i++;
            price /= 10;
        }
        for(i -= 1; i >= 0; i--) {
            if(unlucky_numbers.contains(array[i])) {
                array[i] = plus1(array[i]);
                res += array[i] * Math.pow(10, i);
                break;
            }
            res += array[i] * Math.pow(10, i);
        }
        for(i -= 1 ; i >= 0; i--) {
            array[i] = 2;
            res += array[i] * Math.pow(10, i);
        }
        
        return res;
    }
    
    //加1
    public int plus1(int num) {
        switch(num) {
            case 0:return 2;
            case 1:return 2;
            case 4:return 5;
            case 7:return 9;
            case 8:return 9;
            default:return num;
        }
    }

int getLuckyPrice(int price,List<Integer> unlucky_numbers){
    int[] nums = new int[10];
    Arrays.fill(nums, -1);
    Set<Integer> set = new HashSet<>();
    int pre = 0;
    int use = 1;
    // 给每个数字做映射，除了unlucky都是lucky
    // 如果是lucky，就是它自己
    // 如果是unlucky，那么就是比它大的最小的那个lucky
    while(use < 10) {
        if(!set.contains(use)) {
            for(int i = pre; i <= use; i++) {
                nums[i] = use;
                pre = use;
            }
        }
        use++;
    }
    int p = price;
    StringBuilder sb = new StringBuilder();
    while(p > 0) {
        sb.append(p%10);
        p /= 10;
    }
    sb.reverse();
    // price 直接从前向后遍历
    // 找到第一个unlucky
    char[] chs = sb.toString().toCharArray();
    int idx = 0;
    for(; idx < chs.length; idx++) {
        if(set.contains(chs[idx]-'0')) {
            break;
        }
    }
    // 如果没有不能用0的限制，这个unlucky后面的数字都写0就行
    // 如果首位就是unlucky，那么直接全上 0 对应的 lucky
    if(idx == 0) {
        int res = nums[1];
        for(int i = 0; i < chs.length; i++) {
            res *= 10;
            res += nums[0];
        }
        return res;
    } 
    // 要看 idx 对应的是不是 9，如果9是unlucky，那么需要调整idx-1位
    else {
        if(nums[chs[idx]-'0'] != -1) {
            chs[idx] = '0' + nums[chs[idx]-'0'];
            idx += 1;
        } else {
            chs[idx-1] = '0' + nums[chs[idx-1]-'0'];
        }
        for(; idx < chs.length; idx++) {
            chs[idx] = '0' + nums[0];
        }
        int res = 0;
        for(int i = 0; i < chs.length; i++) {
            res *= 10;
            res += nums[0];
        }
        return res;
    }
}

public class getLuckyPrice {
    public static void main(String[] args){
        //  有一个lucky_numbers存放升序存放1-9的幸运值
        // 每次都从低位开始替换 如果被替换的数小于这位原本的数说明有进位 将剪掉低位的数+1再循环
        // 直到没有数需要被替换
        Scanner in = new Scanner(System.in);
        while (in.hasNext()){
            int original_price = in.nextInt();
            ArrayList<Integer>lucky_numbers = new ArrayList<Integer>();
            for (int i = 1; i < 10; i++) {
                lucky_numbers.add(i);
            }
            int unluncky_count= in.nextInt();
            int unluck_num;
            for (int i = 0; i < unluncky_count; i++) {
                unluck_num = in.nextInt();
                // java不太熟练 之后发现下面的可以用这个代替 lucky_numbers.remove(new Integer(unluck_num))
                int pos = left_pos(lucky_numbers, unluck_num);
                lucky_numbers.remove(pos);
            }
            ArrayList<Integer> result = new ArrayList<Integer>();
            while(original_price > 0) {
                int price_i = original_price % 10;
                original_price /= 10;
                int res = get_lucky_num(price_i, lucky_numbers);
                if(res < price_i){
                    original_price ++;
                }
                result.add(0,  res);
            }
            for (int num:result) {
                System.out.print(num);
            }
        }
    }
    private static int get_lucky_num(int price, ArrayList<Integer>lucky_numbers) {
        int pre = lucky_numbers.get(0);
        int result = price;
        int i;
        for (i = 1; i < lucky_numbers.size(); i++) {
            if(pre == result){
                break;
            }else if(pre < price && price <= lucky_numbers.get(i)){
                result = lucky_numbers.get(i);
                break;
            }
        }
        if(i == lucky_numbers.size()){
            result = lucky_numbers.get(0);
        }
        return result;
    }
    private static int left_pos(ArrayList<Integer>lucky_numbers, int num){
        int low = 0;
        int high = lucky_numbers.size() - 1;
        int mid;
        while(low < high){
            mid = (low + high) / 2;
            if(lucky_numbers.get(mid) >= num){
                high = mid;
            }else{
                low = mid + 1;
            }
        }
        return low;
    }
}

	





	//求你们楼上别误人子弟了，先把题目看懂了行吗，不吉利数字是固定的吗？ 



	//最高位++，后面替换成最小数也不对，没有考虑中间数字进位的情况 



	//我们可以先求出最小吉利数min，然后第一次从低位向高位遍历，把所有数字替换成比它稍大的吉利数，有进位则进位；



	



	//第二次再从高位到低位，找到比原数字大的最高位，保持这一位不变，将后面所有数字替换成min



	//其中最高位进位成‘10’在最后再做特殊处理。



	#include <iostream> 

    #include <vector>
    #include <string.h>
    #include <sstream>
    #include <algorithm>
    using namespace std;
    
    int get_lucky_price(int price, const vector<int> & unlucky_numbers){
        int tmp=-1,min=0;
       //将0添加到数组并排序，方便计算（参数是const，只能额外创建数组）
       vector<int> unlucky_numbers2(unlucky_numbers);
       unlucky_numbers2.push_back(0);
       sort(unlucky_numbers2.begin(),unlucky_numbers2.end());
        //找到不在数组中的最小数字min，相当于示例中的2
        for(int i =0;i<10;++i)
            if (i!=unlucky_numbers2[i]){
                min=i;
                break;
            }
        char res[10]={},str[10]={};
        //把整数转换成字符数组
        stringstream s;
        s<<price;
        s>>res;
        s>>str;
        //从最低位开始替换
        for(int i=strlen(res)-1;i>=0;--i)
            for(int j=0;j<unlucky_numbers2.size();++j)
                if(res[i]-'0' == unlucky_numbers2[j]){
                 tmp=i;//记录当前处理的字符下标i
                    res[i]++;
                 if (res[i]-'0'==10 && i>0){
                    //如果进位，将前一位+1，当前位直接变成min
                    res[--i]++;
                    res[i+1]=min+'0';
                    //同理，如果+1后前一位也进位，依次处理（应对类似9999这种情况）
                    while (res[i]-'0'==10 && i>0){//这里先不处理最高位进位的情况，放到转换的时候
                        res[--i]++;
                        res[i+1]=min+'0';
                    }
                    i=tmp;//i要回位
                }
             }   
        //把后面的数字替换成min
        for(int i=0;i<strlen(res);++i)
                if(res[i]-'0' >str[i]-'0' && res[i]-'0'!=10){
                    for(int j=i+1;j<strlen(res);++j)
                            res[j]=min+'0';
                    break;
                }
                   
        int num=0,i=0;
        //把字符数组转换回整数
        while(res[i]){
          //如果最高位是9，且9也是不吉利数字，进位后还需再次替换     
          if (i==0 && res[i]-'0'==10)
              res[i]=min*10+min+'0';
           num = num*10 +(res[i++]-'0');
        }
        return num;
    }  

	

def get_lucky_price(price,unlucky_numbers):
     
    new_unlucky_numbers = unlucky_numbers + [0]    
    price_list = [int(i) for i in str(price)]
     
    inter_list = list(set(price_list).intersection(set(new_unlucky_numbers)))
     
    if inter_list == []:
        lucky_price = price
        return lucky_price
    else:
        price += 1
        return get_lucky_price(price,unlucky_numbers)
     
 
price = int(input())
unlucky_numbers = list(map(int,input().strip().split()))
print(get_lucky_price(price,unlucky_numbers))

	

package 面试算法;

import java.util.Arrays;
import java.util.List;

public class unLuck {     static int getLuckyPrice(int price,List<Integer> unlucky_numbers){         int tag=0;         int num=1;         while(price>=num) {             //测出位数             num=num*10;             tag++;         }         int[] bit=new int[tag];         for(int i=0;i<tag;i++) {             bit[i]=price%10;             //除法与求余搞清楚             price=(price-bit[i])/10;         }         int result=0,iin=1;         for(int i=0;i<tag;i++) {             if(bit[i]==1) {                 bit[i]=2;             }             if(bit[i]==4) {                 bit[i]=5;             }             if(bit[i]==7) {                 bit[i]=9;             }             if(bit[i]==8) {                 bit[i]=9;             }             if(bit[i]==0) {                 bit[i]=2;             }             result=result+bit[i]*iin;             iin=iin*10;         }         return result;     }     public static void main(String[] args) {         List<Integer> unLuck= Arrays.asList(1,4,7,8);         int result=getLuckyPrice(10001,unLuck);         System.out.println(result);     }

}

	

#试用python写了一个 

def getLuckyPrice(price):
    price = str(price) 
    unlucky_numbers = list(map(int,list(price)))
    unlucky_list = [0,1,4,7,8]#这个是不幸运的数字列表

    #不吉利就加1，直到吉利
    for i in range(len(unlucky_numbers)):
        while unlucky_numbers[i] in unlucky_list:
            unlucky_numbers[i] += 1

    lucky_numbers = ''.join([str(x) for x in unlucky_numbers])
    return int(lucky_numbers)

// ConsoleApplication1.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <algorithm>
#include <string.h>
#include <string>
#include <math.h>
#include <vector>
#include <map>

using namespace std;
const int MaxS = 100 + 10;

int get_lucky_price(int price, const vector<int> & unlucky_numbers) {
 bool is_unlucky[MaxS];
 for (int i = 0;i < unlucky_numbers.size();i++) {
  is_unlucky[unlucky_numbers[i++]] = true;
 }
 char ch[MaxS];
 sprintf(ch, "%d", price);
 int len = strlen(ch);
 for (int i = 0;i < len;i++) {
  while (is_unlucky[ch[i] - '0'] == true) {
   ch[i] = '0' + (ch[i] + 1 - '0') % 10;// 让ch[i]的取值在 0 - 9 之间循环。
  }
 }
 string s = ch;
 return stoi(s);
}

int main()
{
 freopen("Text.txt", "r", stdin);
 int price = 0,tp = 0;
 vector <int> unnums;
 scanf("%d", &price);
 while (scanf("%d", &tp)!=EOF){
  unnums.push_back(tp);
 }
 int lucky_price = get_lucky_price(price,unnums);
 printf("%d\n", lucky_price);
    return 0;
}

	
int function(int a)
{
    switch (a)
    {      
        case 1: return 2; break;
        case 4: return 5; break;
        case 7: return 9; break;
        case 8: return 9; break;
    default:
        return a; break;
    }
}


	int get_lucky_price(int price, const vector<int> & unlucky_numbers)

{

    //TODO

    vector<int> a;

    if (price >= 10)

    {

        if (price % 10 == 0)

        {

            a.push_back(1);

        }

        else

        {

            a.push_back(function(price % 10));

        }

        get_lucky_price(price / 10, unlucky_numbers);

    }

    else

    {

        a.push_back(function(price));

        for (int a.size - 1; i>0; i++)

        {

            cout << a[i];

        }

    }

}