给定正整数n(n 100000),找到最小的由0,1组成

def is_suitable(m):
    # m是否满足有1 0 组成
    for digit in m:
        if digit != '1' and digit != '0':
            return False
    return True

def is_repeat(n, tmp_k):
    """
    如果每次要往前填的数字序列重复超过2次则必然存在死循环
    """
    end_num_list = []
    while tmp_k > 0:
        tmp = tmp_k % 10
        end_num_list.insert(0, tmp * n % 10)
        tmp_k //= 10
    len_num = len(end_num_list)
    if len_num < 2:
        return False
    i = len_num - 1
    while i > 1:
        mid = i // 2
        if(end_num_list[0:mid+1] == end_num_list[mid+1:i+1]):
            return i
        i -= 1
    return False

def tests(n, multi_dict, tmp_k, min_k=None):
    """
    基于树的深度的遍历
    如果这个节点不可取就回溯上一个节点 
    不可取情况：
    1.这个节点构成的值大于目前存在的min_k 此时返回min_k就是k最小情况; 
    2.这个节点构成的k存在死循环  返回造成循环的长度的负数作为标记 直到回溯到不能造成循环的节点
    
    最后在所有树里面选一个结果最小的k
    eg:
    n = 7 -> {7: [1], 4: [2], 1: [3], 8: [4], 5: [5], 2: [6], 9: [7], 6: [8], 3: [9]}
                      3 ( n=7只有一棵树)
            /                 \
           4                     7
         /   \                /    \
        1     4              5      8
       /     / \           /   \   /  \
     [1001] 1   4         8     1 ..  ..
           /     \       / \   / \
     [10101‬] [repeat]   2   5 .. ..
                       /   / \
                  [repeat] .. ..
    
    """
    m = n*tmp_k
    str_m = list(str(m))
    str_tmp_k = str(tmp_k)
    if is_suitable(str_m[0:len(str_m)-len(str_tmp_k)]):  # 如果m排除k长度必然满足条件部分仍满足条件 说明已经找到
        return tmp_k
    end_num = (10 - (tmp_k * n) // (10 ** len(str_tmp_k))) % 10
    repeat_len = is_repeat(n, tmp_k)
    if repeat_len > 0:  # 判断重复  如果一直循环 不可能有解
        return  - repeat_len
    j_list = []
    if end_num in multi_dict:
        j_list.extend(multi_dict[end_num])
    if end_num + 1 in multi_dict:
        j_list.extend(multi_dict[end_num+1])
    if not j_list:
        return False
    min_result = False
    for j in j_list:
        next_tmp_k = tmp_k + j * 10 ** len(str_tmp_k)
        if min_k and next_tmp_k // min_k > 0:  # 如果min_k存在 但目前要求的tmp_k比min_k大就没必要继续向下查询 直接返回min_k即可
            return min_k
        if min_result:
            result = tests(n, multi_dict, next_tmp_k, min_result)
        else:
            result = tests(n, multi_dict, next_tmp_k)
        if result < 0:  # 小于零表示选这个j会造成死循环  result的绝对值表示k数字中造成死循环的长度
            result += 1
            if result == 0:    # 这个j不被纳入考虑 如果j_list里还有存在的j就选下一个 没有就返回min_result
                continue
            return result
        if not min_result or (result and min_result > result):
            min_result =  result
    return min_result

if __name__ == '__main__':
    multi_dict = {}
    for i in range(1,10):
        tmp = i * n % 10
        if tmp not in multi_dict:
            multi_dict[tmp] = []
        multi_dict[tmp].append(i)
    j_list = []
    if 0 in multi_dict:
        j_list.extend(multi_dict[0])
    if 1 in multi_dict:
        j_list.extend(multi_dict[1])
    min_result = None
    for  j in j_list:
        result = tests(n, multi_dict, j)
        if result and (min_result is None or min_result > result):
            min_result = result
    if min_result:
        print(min_result*n)
    print(-1)  # 没有符合要求的