题意：给定一个整数n,求n的一个倍数，要求这个倍数只含0和1
参考博客：点我
解法一：普通的BFS(用G++能过但C++会超时)
从小到大搜索直至找到满足条件的数，注意最高位一定为1
假设 n=6 k即为当前所求的目标数，不满足条件则进一步递推 （i 为层数（深度），在解法二的优化中体现，此时可以不管)
1%6=1 (k=1) i=1
{
(1*10+0)%6=4 (k=10) i=2
{
(10*10+0)%6=4 (k=100) i=4
{
(100*10+0)%6=4 (k=1000) i=8
(100*10+1)%6=5 (k=1001) i=9
}
(10*10+1)%6=5 (k=101) i=5
{
(101*10+0)%6=2 (k=1010) i=10
(101*10+1)%6=3 (k=1011) i=11
}
}
(1*10+1)%6=5 (k=11) i=3
{
(11*10+0)%6=2 (k=110) i=6
{
(110*10+0)%6=2 (k=1100) i=12
(110*10+1)%6=3 (k=1101) i=13
}
(11*10+1)%6=3 (k=111) i=7
{
(111*10+0)%6=0 (k=1110) i=14 有解
(111*10+1)%6=1 (k=1111) 由于前面有解，这个余数不存储
}
}
}
可以看到，如此反复枚举下去，直至找到目的数k为止，注意若当前k不满足条件，则将k*10 和k*10 + 1入队以便进一步判断
以下是解法一的代码，用G++能过，但用C++超时(我是在hust交的)，不知道为什么！
/* POJ 1426 Find The Multiple BFS 用C++超时但G++过了*/
#include <cstdio>
#include <queue>
using namespace std; /*返回最大能整除n的只有1和0组成的数*/
long long bfs(int n){
long long tmp;
queue<long long> q;
q.push();
while (!q.empty()){
tmp = q.front();
q.pop();
if (tmp % n == ){
return tmp;
}
q.push(tmp * );
q.push(tmp * + );
}
return ;
} int main()
{
int n;
while (scanf("%d", &n) == && n){
printf("%lld\n", bfs[n]);
} return ;
}
解法二：优化的BFS(C++能过)
由于C++超时，于是我参考了以下别人的代码，地址上面已给出，但为了加深记忆，还是自己写一遍！
同余定理的应用：
(a+b)%n = (a%n + b%n)%n
(a*b)%n = (a%n * b%n)%n
在解法一中，由于一直*10, k有可能出现越界，具体请参考原博客，在这里只写余数优化过程：
取解法一中的任意式子：
前一层: mod = (11*10 + 0)%6 = 2, k = 110, i = 6, k % 6 = 2
后一层: mod = (k'*10 + 0) %6 //注意这里的k'为上一层的k,即110, 另此层k为110*10 + 0, i 为6 * 2
=( (k'*10)%6 + 0%6 ) % 6
=( (k'%6 * 10%6) % 6 + 0%6) % 6 //k'%6即为上一层的mod,记为mod', 在这个例子中就是2, 另k'%6 = mod' = mod'%6
=( (mod'6 * 10%6) % 6 + 0%6) % 6
=( (mod' * 10) % 6 + 0 % 6) % 6
= (mod'*10 + 0) % 6; //即当前层的mod=前一层的mod*10 + 0 (具体是0还是1和i有关) 因为0、1是循环取的
为了加强理解，再推导一遍i为奇数的过程
前一层：mod = (11*10 + 0)%6 = 2, k = 110, i = 6, k % 6 = 2
后一层: mod = (k'*10 + 1) % 6 //此层 k = 110*10+1, i 为6*2+1
= ( (k'%6 * 10%6) % 6 + 1 % 6) % 6
= ( mod' * 10 + 1) % 6 //即当前层的mod=前一层的mod*10 + 1(具体是0和1和i有关)
这样就化简了求模的过程，共经过i步求模获得当前的目标数k % n = 0(但此时并不知道k具体的值)，只知道求mod的过程
要通过操作数获取k，我是这样理解的：
经过i步得到满足条件的数k(尽管k暂时还不知道)， 由于每个数会产生两个分支，即k是由 i / 2 层的数k'递推而来的。 即 k'/2 * 2 + 0或1. 因此要知道k的末位是0还是1只要考虑当前k的奇偶性，因为2 * i / 2一定是偶数，奇偶性就是由后面的1或者0来决定的！如果是奇数，则证明当前k的最后一位是1,否则是0，值得注意的是：k的奇偶性和i的奇偶性恰巧是相同的，由于每个数会产生两个新的数字，可以看成是一棵二叉树， 如图：
结点编号即为获取当前k（括号里的数）所需要的操作步数，可以看到k与编号的奇偶性是恰好相同的,因此利用操作步数i， 循环i%2 与i/ = 2 就可以获取目标数的各个位(注意是从叶子到根得到的各个位置上的数(即先得到后面的位的数)，因此输出时需要到过来)，
优化后的BFS的代码：
/* POJ 1426 Find The Multiple BFS 优化*/
#include <cstdio> int mod[]; //寸模,参考别人的计算这是最小的AC下限 int main()
{
int n;
while (scanf("%d", &n) == && n){
mod[] = ;
int i;
for (i = ; mod[i - ] != ; ++i){
//该公式前面已证明, 注意:i为奇偶数分别对应 i%2 = 1和0
mod[i] = (mod[i/] * + i % ) % n; // i/2为前一层
}
--i; //i此时为取模的次数
int p = ;
while (i){
mod[p++] = i % ; //操作次数转化成所要的数--->k(可用二叉树理解)
i /= ;
}
while (p){
printf("%d", mod[--p]); //逆序输出即为目的数
}
printf("\n");
} return ;
}
解法三： 这题还可以用DFS通过控制递归深度直接过
/* POJ 1426 Find The Multiple --- DFS */
#include <cstdio> int n;
bool flag; void dfs(unsigned long long tmp, int i){
if (flag || i > )
return;
if (tmp % n == ){
flag = ;
printf("%llu\n", tmp);
return ;
}
else{
dfs(tmp * , i+);
dfs(tmp * + , i+);
}
} int main()
{
while (scanf("%d", &n) == && n){
flag = ;
dfs(,);
} return ;
}