解決這個問題首先考慮對於任意的N，是否這樣的M一定存在。可以證明，M是一定存在的，而且不唯一。
簡單證明：因為

 

這是一個無窮數列，但是數列中的每一項取值範圍都在[0, N-1]之間。所以這個無窮數列中間必定存在迴圈節。即假設有s,t均是正整數，且s<t，有 。於是迴圈節長度為t-s。於是10^s = 10^t。因此有：
，所以

例如，取N＝3，因為10的任何非負次方模3都為1，所以迴圈節週期為1.有：

給定N，求M的方法：
方法一：給定N，令M從2開始，列舉M的值直到遇到一個M使得N*M的十進位制表示中只有1和0.
方法二：求出10的次方序列模N的餘數序列並找出迴圈節。然後搜尋這個餘數序列，搜尋的目的就是要在這個餘數序列中找到一些數出來讓它們的和是N的倍數。例如N=13，這個序列就是1,10,9,12,3,4然後不斷迴圈。很明顯有1+12=13，而1是10的0次方，12是10的3次方，所以這個數就是1000+1=1001，M就是1001/13=77。
方法三

：因為N*M的取值就是1,10,11,100,101,110,111,......所以直接在這個空間搜尋，這是對方法一的改進。搜尋這個序列直到找到一個能被N整除的數，它就是N*M，然後可計算出M。例如N=3時，搜尋樹如下：

上圖中括號內表示模3的餘數。括號外表示被搜尋的數。左子樹表示0，右子樹表示1.上圖中搜索到第二層（根是第0層）時遇到111，它模3餘數為0.所以N*M=111, M=111/3=37。
方法四：對方法三的改進。將方法三的搜尋空間按模N餘數分類，使得搜尋時間和空間都由原來的指數級降到了O(N)。改進的原理：假設當前正在搜尋由0，1組成的K位十進位制數，這樣的K位十進位制數共有2^k個。假設其中有兩個數X、Y，它們模N同餘，那麼在搜尋由0、1組成的K+1位十進位制數時，X和Y會被擴展出四個數：10X, 10X+1, 10Y, 10Y+1。因為X和Y同餘（同餘完全可以看作相等），所以10X與10Y同餘，10X+1與10Y+1同餘。也就是說由Y擴展出來的子樹和由X擴充套件產生出來的子樹產生完全相同的餘數，如果X比Y小，那麼Y肯定不是滿足要求的最小的數，所以Y這棵子樹可以被剪掉。這樣，2^K個數按照模N餘數分類，每類中只保留最小的那個數以供擴充套件。原來在這一層需要搜尋2^K個數，現在只需要搜尋O(N)個數。例如，當N=9時，第0層是1(1)，

如上圖所示，第2層的110，第三層的1010、1110都因為同一層有和它同餘且更小的數而被剪掉。如果按照方法三搜尋，第三層本來應該有8個結點，但現在只有4個結點。

方法一的原始碼：

1. #include <stdio.h>
2. int HasOnlyOneAndZero(unsigned int n) {  
3.     while(n) {  
4.         if(n % 10 >= 2) return 0;  
5.         n /= 10;  
6.     }  
7.     return 1;  
8. }  
9. int main() {  
10.     int n, m;  
11.     while(scanf(
    "%d", &n) != EOF) {  
12.         for(m = 1;;m++) {  
13.             if(HasOnlyOneAndZero(n*m)) {  
14.                 printf("n = %d, m = %d, n*m = %d/n", n, m, n*m);  
15.                 break;  
16.             }  
17.         }  
18.     }  
19.     return 0;  
20. }  

方法三的原始碼：

1. // 解法三(1):廣度優先搜尋
2. #define _CRT_SECURE_NO_WARNINGS 1
3. #include <cstdio>
4. #include <queue>
5. usingnamespace std;  
6. int main() {  
7.     int N;  
8.     while(scanf("%d", &N) != EOF) {  
9.         queue<int> q;  
10.         q.push(1);  
11.         while(!q.empty()) {  
12.             int t = q.front();  
13.             q.pop();  
14.             if(t % N == 0) {  
15.                 printf("n = %d, m = %d, n*m = %d/n", N, t/N, t);  
16.                 break;  
17.             }  
18.             q.push(t * 10);  
19.             q.push(t * 10 + 1);  
20.         }  
21.     }  
22.     return 0;  
23. }  

方法四原始碼：

1. // 解法四：將搜尋空間分過類的廣度搜索，這樣空間佔用是O(N)而不是
2. // 指數級。分類的原則是按照模N的餘數分類　
3. #define _CRT_SECURE_NO_WARNINGS 1
4. #include <cstdio>
5. #include <bitset>
6. #include <vector>
7. #include <queue>
8. usingnamespace std;  
9. struct QNode {  
10.     int v, r; // v is value, r is remainder
11.     QNode(int vv, int rr): v(vv), r(rr) {}  
12.     QNode(): v(0), r(0) {}  
13. };  
14. int main() {  
15.     int N;  
16.     while(scanf("%d", &N) != EOF) {  
17.         //bitset<N> bn;
18.         queue<QNode> q;  
19.         q.push(QNode(1, 1));  
20.         while(!q.empty()) {  
21.             //bn.reset();
22.             vector<bool> bn(N, false);  
23.             int s = q.size();  
24.             while(s--) {  
25.                 QNode t = q.front();  
26.                 if(t.r == 0) {  
27.                     printf("n = %d, m = %d, n*m = %d/n", N, t.v/N, t.v);  
28.                     goto ok;  
29.                 }  
30.                 q.pop();  
31.                 if(!bn[t.r * 10 % N]) {  
32.                     bn[t.r * 10 % N] = true;  
33.                     q.push(QNode(t.v * 10, t.r * 10 % N));  
34.                 }  
35.                 if(!bn[(t.r * 10 + 1) % N]) {  
36.                     bn[(t.r * 10 + 1) % N] = true;  
37.                     q.push(QNode(t.v * 10 + 1, (t.r * 10 + 1) % N));  
38.                 }  
39.             }  
40.         }  
41. ok:;  
42.     }  
43.     return 0;  
44. }