POJ3185(简单BFS，主要做测试使用)

没事做水了一道POJ的简单BFS的题目

这道题的数据范围是20,所以状态总数就是（1<<20）

第一次提交使用STL的queue，并且是在队首判断是否达到终点，达到终点就退出，超时：（其实这里我是很不明白的，，TM状态总数就只有1e6怎么也不应该超时的，，，，只能说STL的queue的常数实在是太大，完全没法弄。。。）

 #include <map>
 #include <set>
 #include <stack>
 #include <queue>
 #include <cmath>
 #include <ctime>
 #include <vector>
 #include <cstdio>
 #include <cctype>
 #include <cstring>
 #include <string.h>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 #define INF 1e9
 #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 FOPENIN(IN) freopen(IN, "r", stdin)
 #define FOPENOUT(OUT) freopen(OUT, "w", stdout)
 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;      }
 template<class T> void SWAP(T& a, T& b) { T x = a; a = b; b = x; }

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

 int step[<<];
 bool vis[<<];

 int BFS(int s)
 {
     vis[s] = ;
     queue<int>q;
     q.push(s);
     step[s] = ;
     while(!q.empty())
     {
         int u = q.front(); q.pop();
         if(u == )  return step[u];
         for(int i=;i<;i++)
         {
             int r = u;
             r ^= (<<i-) | (<<i) | (<<i+);
             if(!vis[r])
             {
                 vis[r] = ;
                 step[r] = step[u] + ;
                 q.push(r);
             }
         }
         int r = u ^ (<<) ^ (<<);
         if(!vis[r]) { vis[r] = ; step[r] = step[u] + ; q.push(r); }
         r = u ^ (<<) ^ (<<);
         if(!vis[r]) { vis[r] = ; step[r] = step[u] + ; q.push(r); }
     }
     return -;
 }

 int main()
 {
         //FOPENIN("in.txt");
         int st = , x;
         for(int i=;i<;i++)
         {
             scanf("%d", &x);
             st |= (x<<i);
         }
         printf("%d\n", BFS(st));
         return ;
 }

TLE后马上把判断放到队尾（就是说在一个状态进队列前先判断是不是终点状态，是的话就退出），跑了875ms，勉强过了，，（这里我就是乱改的了，代码没任何观赏性）

 #include <map>
 #include <set>
 #include <stack>
 #include <queue>
 #include <cmath>
 #include <ctime>
 #include <vector>
 #include <cstdio>
 #include <cctype>
 #include <cstring>
 #include <string.h>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 #define INF 1e9
 #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 FOPENIN(IN) freopen(IN, "r", stdin)
 #define FOPENOUT(OUT) freopen(OUT, "w", stdout)
 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;      }
 template<class T> void SWAP(T& a, T& b) { T x = a; a = b; b = x; }

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

 int step[<<];
 bool vis[<<];

 int BFS(int s)
 {
     vis[s] = ;
     queue<int>q;
     q.push(s);
     step[s] = ;
     while(!q.empty())
     {
         int u = q.front(); q.pop();
         if(u == )  return step[u];
         for(int i=;i<;i++)
         {
             int r = u;
             r ^= (<<i-) | (<<i) | (<<i+);
             if(!vis[r])
             {
                 vis[r] = ;
                 step[r] = step[u] + ;
                 if(r==) return step[r];
                 q.push(r);
             }
         }
         int r = u ^ (<<) ^ (<<);
         if(!vis[r]) { vis[r] = ; step[r] = step[u] + ; q.push(r); if(r==) return step[r];}
         r = u ^ (<<) ^ (<<);
         if(!vis[r]) { vis[r] = ; step[r] = step[u] + ; q.push(r); if(r==) return step[r];}
     }
     return -;
 }

 int main()
 {
         //FOPENIN("in.txt");
         int st = , x;
         for(int i=;i<;i++)
         {
             scanf("%d", &x);
             st |= (x<<i);
         }
         printf("%d\n", BFS(st));
         return ;
 }

然后突然想起之前写过一个静态队列的模板，是用循环队列写的，想着正好去测试下，就改了队列的定义，其他使用完全一致，没任何修改，结果跑了250ms快了好多了啊有木有。。

 #include <map>
 #include <set>
 #include <stack>
 #include <queue>
 #include <cmath>
 #include <ctime>
 #include <vector>
 #include <cstdio>
 #include <cctype>
 #include <cstring>
 #include <string.h>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 #define INF 1e9
 #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 FOPENIN(IN) freopen(IN, "r", stdin)
 #define FOPENOUT(OUT) freopen(OUT, "w", stdout)
 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;      }
 template<class T> void SWAP(T& a, T& b) { T x = a; a = b; b = x; }

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

 //MyQueue<Type>q;
 //定义了一个固定长度的队列， 不能动态增长
     //构造时不传参数，队列大小为1e5，传入参数时为自定义大小
     //如果队列不为空，front返回队首元素，
     //如果队列为空，pop无效，front返回NULL
     //clear将队列清空, 供多次使用
     //如果push时产生冲突，即队列已满， 将加入失败
 template <class T>
 class MyQueue
 {
 private:
     T* que;
     int si, fr, re;
     void setValue(int _size) {
         fr = ; re = ;
         si = _size;
         que = (T*)malloc(si * sizeof(T));
     }
 public:
     MyQueue() {
         this->setValue();
     }
     MyQueue(int _size) {
         this->setValue(_size);
     }
     T front() {
         if(fr != re)
             return que[fr];
         return NULL;
     }
     void pop() {
         if(fr != re)
             fr = (fr + ) % si;
     }
     void push(T e) {
         if((re + ) % si == fr) return ;
         que[re] = e;
         re = (re + ) % si;
     }
     bool empty() {
         if(fr == re) return ;
         return ;
     }
     void clear() {
         fr = ;
         re = ;
     }
 };

 int step[<<];
 bool vis[<<];

 int BFS(int s)
 {
     vis[s] = ;
     MyQueue<int>q(<<);//定义队列的大小为(1<<21),其他无任何修改
     q.push(s);
     step[s] = ;
     while(!q.empty())
     {
         int u = q.front(); q.pop();
         if(u == )  return step[u];
         for(int i=;i<;i++)
         {
             int r = u;
             r ^= (<<i-) | (<<i) | (<<i+);
             if(!vis[r])
             {
                 vis[r] = ;
                 step[r] = step[u] + ;
                 q.push(r);
             }
         }
         int r = u ^ (<<) ^ (<<);
         if(!vis[r]) { vis[r] = ; step[r] = step[u] + ; q.push(r); }
         r = u ^ (<<) ^ (<<);
         if(!vis[r]) { vis[r] = ; step[r] = step[u] + ; q.push(r); }
     }
     return -;
 }

 int main()
 {
         //FOPENIN("in.txt");
         int st = , x;
         for(int i=;i<;i++)
         {
             scanf("%d", &x);
             st |= (x<<i);
         }
         printf("%d\n", BFS(st));
         return ;
 }

最后试着把终点判断放在队头，依然360ms就跑出来了啊，，，我就哭了。。。