ZOJ 3596Digit Number（BFS+DP）

一道比较不错的BFS+DP题目

题意很简单，就是问一个刚好包含m(m<=10)个不同数字的n的最小倍数。

很明显如果直接枚举每一位是什么这样的话显然复杂度是没有上限的，所以需要找到一个状态表示方法：

令F[i][j] 表示已经用了 i (二进制压位表示)用了 i 这些数字，且余数j为的状态，枚举时直接枚举当前位，那么答案明显就是F[m][0]

我这里将状态i, j存在了一维空间里，即 i * 1000 + j表示，实际上用一个结构体存队列里的点，用二维数组标记状态也是可行的。

 #include <map>
 #include <set>
 #include <stack>
 #include <queue>
 #include <cmath>
 #include <ctime>
 #include <vector>
 #include <cstdio>
 #include <cctype>
 #include <cstring>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 #define INF 0x3f3f3f3f
 #define inf (-((LL)1<<40))
 #define lson k<<1, L, mid
 #define rson k<<1|1, mid+1, R
 #define mem0(a) memset(a,0,sizeof(a))
 #define mem1(a) memset(a,-1,sizeof(a))
 #define mem(a, b) memset(a, b, sizeof(a))
 #define FIN freopen("in.txt", "r", stdin)
 #define FOUT freopen("out.txt", "w", stdout)
 #define rep(i, a, b) for(int i = a; i <= b; i ++)

 template<class T> T CMP_MIN(T a, T b) { return a < b; }
 template<class T> T CMP_MAX(T a, T b) { return a > b; }
 template<class T> T MAX(T a, T b) { return a > b ? a : b; }
 template<class T> T MIN(T a, T b) { return a < b ? a : b; }
 template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
 template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }

 //typedef __int64 LL;
 typedef long long LL;
 const int MAXN = ;
 const int MAXM = ;
 const double eps = 1e-;
 //LL MOD = 987654321;

 int t, n, m, x;
 struct Node {
     bool vis;
     char num;
     int pre, cnt;
 }s[(<<) * ];
 char ans[], d[];

 int bfs()
 {
     queue<int>q;
     q.push();
     while(!q.empty()) {
         int head = q.front();q.pop();
         rep (i, , ) {
             if(head ==  && i == ) continue;
             int mod = (head %  *  + i) % n;
             int tail = ((head / ) | ( << i)) *  + mod;
             if(s[tail].vis)
                 continue;
             s[tail].vis = true;
             s[tail].num = i + '';
             s[tail].pre = head;
             s[tail].cnt = s[head].cnt + ((head / ) & ( << i) ?  : );
             if(s[tail].cnt == m && mod == ) {
                 return tail;
             }
             if(s[tail].cnt <= m) q.push(tail);
         }
     }
     return ;
 }

 //calc a / b
 char* divide(char *a, int len, int b) {
     mem0(d);
     int i = , cur = , l = ;
     while(cur < b && i < len) {
         cur = cur *  + a[i++] - '';
     }
     d[l++] = cur / b + '';
     while(i < len) {
         cur = cur % b *  + a[i++] - '';
         d[l++] = cur / b + '';
     }
     return d;
 }

 void print(int ed) {
     int len = ;
     mem0(ans);
     while(ed) {
         ans[len++] = s[ed].num;
         ed = s[ed].pre;
     }
     reverse(ans, ans + len);
     printf("%s=%d*%s\n", ans, n, divide(ans, len, n));
 }

 int main()
 {
     //FIN;
     while(cin >> t) while(t--) {
         cin >> n >> m;
         mem0(s);
         if( !(x = bfs()) ) {
             puts("Impossible");
         }
         else {
             print(x);
         }
     }
     return ;
 }