POJ1077 Eight —— 双向BFS

最新推荐文章于 2020-03-18 15:43:01 发布
最新推荐文章于 2020-03-18 15:43:01 发布
阅读量114 收藏
点赞数
原文链接：http://www.cnblogs.com/DOLFAMINGO/p/7538585.html
版权

主页面：http://www.cnblogs.com/DOLFAMINGO/p/7538588.html

（代码一直在精简完善……）



代码一：两个BFS， 两段代码； 用step控制“你一步， 我一步”。

  1 #include <iostream>
  2 #include <cstdio>
  3 #include <cstring>
  4 #include <cmath>
  5 #include <algorithm>
  6 #include <vector>
  7 #include <queue>
  8 #include <stack>
  9 #include <map>
 10 #include <string>
 11 #include <set>
 12 #define ms(a,b) memset((a),(b),sizeof((a)))
 13 using namespace std;
 14 typedef long long LL;
 15 const int INF = 2e9;
 16 const LL LNF = 9e18;
 17 const int MOD = 1e9+7;
 18 const int MAXN = 1e6+10;
 19 
 20 struct node
 21 {
 22     int status;
 23     int s[9];
 24     int loc;
 25     int step;   //双向bfs需要记录第几步，才能做到“你一步，我一步”
 26 };
 27 
 28 int fac[9] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320};
 29 int dir1[4][2] = { -1,0, 1,0, 0,-1, 0,1 };  //正方向
 30 char op1[4] = {'u', 'd', 'l', 'r'  };
 31 int dir2[4][2] = {0,1, 0,-1, 1,0, -1,0};    //反方向
 32 char op2[4] = {'l', 'r', 'u', 'd'  };
 33 
 34 char path1[MAXN], path2[MAXN];  //1为正方向，2为反方向，以下皆如此
 35 int pre1[MAXN], pre2[MAXN];
 36 
 37 int cantor(int s[])
 38 {
 39     int sum = 0;
 40     for(int i = 0; i<9; i++)
 41     {
 42         int num = 0;
 43         for(int j = i+1; j<9; j++)
 44             if(s[j]<s[i])
 45                 num++;
 46         sum += num*fac[8-i];
 47     }
 48     return sum+1;
 49 }
 50 
 51 queue<node>q1, q2;
 52 int vis1[MAXN], vis2[MAXN];
 53 int bfs(node now)
 54 {
 55     ms(vis1,0);
 56     ms(vis2,0);
 57     while(!q1.empty()) q1.pop();
 58     while(!q2.empty()) q2.pop();
 59 
 60     now.status = cantor(now.s);
 61     now.step = 0;
 62     pre1[now.status] = -1;
 63     vis1[now.status] = 1;
 64     q1.push(now);
 65 
 66     for(int i = 0; i<9; i++)
 67         now.s[i] = i+1;
 68     now.loc = 8;
 69     now.status = cantor(now.s);
 70     now.step = 0;
 71     pre2[now.status] = -1;
 72     vis2[now.status] = 1;
 73     q2.push(now);
 74 
 75     int time = 0;   //计时器
 76     while(!q1.empty() || !q2.empty())
 77     {
 78         time++;
 79         while(!q1.empty())
 80         {
 81             if(q1.front().step==time)   //时间到了，就让给对方
 82                 break;
 83 
 84             now = q1.front();
 85             q1.pop();
 86 
 87             if(vis2[now.status])    //此状态已被对方访问过，则说明两者“接上了”
 88                 return now.status;
 89 
 90             int x = now.loc/3;
 91             int y = now.loc%3;
 92             for(int i = 0; i<4; i++)
 93             {
 94                 int xx = x + dir1[i][0];
 95                 int yy = y + dir1[i][1];
 96                 if(xx>=0 && xx<=2 && yy>=0 && yy<=2)
 97                 {
 98                     node tmp = now;
 99                     tmp.s[x*3+y] = tmp.s[xx*3+yy];
100                     tmp.s[xx*3+yy] = 9;
101                     tmp.status = cantor(tmp.s);
102                     if(!vis1[tmp.status])
103                     {
104                         vis1[tmp.status] = 1;
105                         tmp.loc = xx*3+yy;
106                         tmp.step++;
107                         path1[tmp.status] = op1[i];
108                         pre1[tmp.status] = now.status;
109                         q1.push(tmp);
110                     }
111                 }
112             }
113         }
114 
115         while(!q2.empty())
116         {
117             if(q2.front().step==time)   //时间到了，就让给对方
118                 break;
119 
120             now = q2.front();
121             q2.pop();
122 
123             if(vis1[now.status])    //此状态已被对方访问过，则说明两者“接上了”
124                 return now.status;
125 
126             int x = now.loc/3;
127             int y = now.loc%3;
128             for(int i = 0; i<4; i++)
129             {
130                 int xx = x + dir2[i][0];
131                 int yy = y + dir2[i][1];
132                 if(xx>=0 && xx<=2 && yy>=0 && yy<=2)
133                 {
134                     node tmp = now;
135                     tmp.s[x*3+y] = tmp.s[xx*3+yy];
136                     tmp.s[xx*3+yy] = 9;
137                     tmp.status = cantor(tmp.s);
138                     if(!vis2[tmp.status])
139                     {
140                         vis2[tmp.status] = 1;
141                         tmp.loc = xx*3+yy;
142                         tmp.step++;
143                         path2[tmp.status] = op2[i];
144                         pre2[tmp.status] = now.status;
145                         q2.push(tmp);
146                     }
147                 }
148             }
149         }
150     }
151     return -1;
152 }
153 
154 
155 void Print1(int status) //输出正方向的路径
156 {
157     if(pre1[status]==-1) return;
158     Print1(pre1[status]);
159     putchar(path1[status]);
160 }
161 
162 void Print2(int status) //输出反方向的路径
163 {
164     if(pre2[status]==-1) return;
165     putchar(path2[status]);
166     Print2(pre2[status]);
167 }
168 
169 int main()
170 {
171     char tmp[50];
172     while(gets(tmp))
173     {
174         node beg;
175         int cnt = 0;
176         for(int i = 0; tmp[i]; i++)
177         {
178             if(tmp[i]==' ') continue;
179             if(tmp[i]=='x') beg.s[cnt] = 9, beg.loc = cnt++;
180             else  beg.s[cnt++] = tmp[i]-'0';
181         }
182         int status = bfs(beg);
183         if(status==-1)
184             puts("unsolvable");
185         else
186         {
187             Print1(status); Print2(status);   //输出路径
188             putchar('\n');
189         }
190     }
191 }
View Code


代码二：两个BFS， 两段代码； 用队列的大小控制“你一步， 我一步”。

  1 #include <iostream>
  2 #include <cstdio>
  3 #include <cstring>
  4 #include <cmath>
  5 #include <algorithm>
  6 #include <vector>
  7 #include <queue>
  8 #include <stack>
  9 #include <map>
 10 #include <string>
 11 #include <set>
 12 #define ms(a,b) memset((a),(b),sizeof((a)))
 13 using namespace std;
 14 typedef long long LL;
 15 const int INF = 2e9;
 16 const LL LNF = 9e18;
 17 const int MOD = 1e9+7;
 18 const int MAXN = 1e6+10;
 19 
 20 struct node
 21 {
 22     int status;
 23     int s[9];
 24     int loc;
 25 };
 26 
 27 int fac[9] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320};
 28 int dir1[4][2] = { -1,0, 1,0, 0,-1, 0,1 };  //正方向
 29 char op1[4] = {'u', 'd', 'l', 'r'  };
 30 int dir2[4][2] = {0,1, 0,-1, 1,0, -1,0};    //反方向
 31 char op2[4] = {'l', 'r', 'u', 'd'  };
 32 
 33 char path1[MAXN], path2[MAXN];  //1为正方向，2为反方向，以下皆如此
 34 int pre1[MAXN], pre2[MAXN];
 35 
 36 int cantor(int s[])
 37 {
 38     int sum = 0;
 39     for(int i = 0; i<9; i++)
 40     {
 41         int num = 0;
 42         for(int j = i+1; j<9; j++)
 43             if(s[j]<s[i])
 44                 num++;
 45         sum += num*fac[8-i];
 46     }
 47     return sum+1;
 48 }
 49 
 50 queue<node>q1, q2;
 51 int vis1[MAXN], vis2[MAXN];
 52 int bfs(node now)
 53 {
 54     ms(vis1,0);
 55     ms(vis2,0);
 56     while(!q1.empty()) q1.pop();
 57     while(!q2.empty()) q2.pop();
 58 
 59     now.status = cantor(now.s);
 60     pre1[now.status] = -1;
 61     vis1[now.status] = 1;
 62     q1.push(now);
 63 
 64     for(int i = 0; i<9; i++)
 65         now.s[i] = i+1;
 66     now.loc = 8;
 67     now.status = cantor(now.s);
 68     pre2[now.status] = -1;
 69     vis2[now.status] = 1;
 70     q2.push(now);
 71 
 72     while(!q1.empty() || !q2.empty())
 73     {
 74         int s1 = q1.size(); //当前队列中的结点步数是一样的，处理完这些结点，得到步数+1的结点
 75         while(s1--)
 76         {
 77             now = q1.front();
 78             q1.pop();
 79 
 80             if(vis2[now.status])    //此状态已被对方访问过，则说明两者“接上了”
 81                 return now.status;
 82 
 83             int x = now.loc/3;
 84             int y = now.loc%3;
 85             for(int i = 0; i<4; i++)
 86             {
 87                 int xx = x + dir1[i][0];
 88                 int yy = y + dir1[i][1];
 89                 if(xx>=0 && xx<=2 && yy>=0 && yy<=2)
 90                 {
 91                     node tmp = now;
 92                     tmp.s[x*3+y] = tmp.s[xx*3+yy];
 93                     tmp.s[xx*3+yy] = 9;
 94                     tmp.status = cantor(tmp.s);
 95                     if(!vis1[tmp.status])
 96                     {
 97                         vis1[tmp.status] = 1;
 98                         tmp.loc = xx*3+yy;
 99                         path1[tmp.status] = op1[i];
100                         pre1[tmp.status] = now.status;
101                         q1.push(tmp);
102                     }
103                 }
104             }
105         }
106 
107         int s2 = q2.size();
108         while(s2--)
109         {
110             now = q2.front();
111             q2.pop();
112 
113             if(vis1[now.status])    //此状态已被对方访问过，则说明两者“接上了”
114                 return now.status;
115 
116             int x = now.loc/3;
117             int y = now.loc%3;
118             for(int i = 0; i<4; i++)
119             {
120                 int xx = x + dir2[i][0];
121                 int yy = y + dir2[i][1];
122                 if(xx>=0 && xx<=2 && yy>=0 && yy<=2)
123                 {
124                     node tmp = now;
125                     tmp.s[x*3+y] = tmp.s[xx*3+yy];
126                     tmp.s[xx*3+yy] = 9;
127                     tmp.status = cantor(tmp.s);
128                     if(!vis2[tmp.status])
129                     {
130                         vis2[tmp.status] = 1;
131                         tmp.loc = xx*3+yy;
132                         path2[tmp.status] = op2[i];
133                         pre2[tmp.status] = now.status;
134                         q2.push(tmp);
135                     }
136                 }
137             }
138         }
139     }
140     return -1;
141 }
142 
143 void Print1(int status) //输出正方向的路径
144 {
145     if(pre1[status]==-1) return;
146     Print1(pre1[status]);
147     putchar(path1[status]);
148 }
149 
150 void Print2(int status) //输出反方向的路径
151 {
152     if(pre2[status]==-1) return;
153     putchar(path2[status]);
154     Print2(pre2[status]);
155 }
156 
157 int main()
158 {
159     char tmp[50];
160     while(gets(tmp))
161     {
162         node beg;
163         int cnt = 0;
164         for(int i = 0; tmp[i]; i++)
165         {
166             if(tmp[i]==' ') continue;
167             if(tmp[i]=='x') beg.s[cnt] = 9, beg.loc = cnt++;
168             else  beg.s[cnt++] = tmp[i]-'0';
169         }
170         int status = bfs(beg);
171         if(status==-1)
172             puts("unsolvable");
173         else
174         {
175             Print1(status); Print2(status);   //输出路径
176             putchar('\n');
177         }
178     }
179 }
View Code

 



代码三：两个队列，调用一段BFS()，用队列的大小控制“你一步， 我一步”。

  1 #include <iostream>
  2 #include <cstdio>
  3 #include <cstring>
  4 #include <cmath>
  5 #include <algorithm>
  6 #include <vector>
  7 #include <queue>
  8 #include <stack>
  9 #include <map>
 10 #include <string>
 11 #include <set>
 12 #define ms(a,b) memset((a),(b),sizeof((a)))
 13 using namespace std;
 14 typedef long long LL;
 15 const int INF = 2e9;
 16 const LL LNF = 9e18;
 17 const int MOD = 1e9+7;
 18 const int MAXN = 1e6+10;
 19 
 20 struct node
 21 {
 22     int status;
 23     int s[9];
 24     int loc;
 25 };
 26 
 27 int fac[9] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320};
 28 int dir[2][4][2] = { -1,0, 1,0, 0,-1, 0,1,   0,1, 0,-1, 1,0, -1,0};  //正方向
 29 char op[2][4] = {'u', 'd', 'l', 'r' ,   'l', 'r', 'u', 'd'  };
 30 
 31 char path[2][MAXN];
 32 int pre[2][MAXN];
 33 
 34 int cantor(int s[])
 35 {
 36     int sum = 0;
 37     for(int i = 0; i<9; i++)
 38     {
 39         int num = 0;
 40         for(int j = i+1; j<9; j++)
 41             if(s[j]<s[i])
 42                 num++;
 43         sum += num*fac[8-i];
 44     }
 45     return sum+1;
 46 }
 47 
 48 queue<node>q[2];
 49 int vis[2][MAXN];
 50 int bfs(int id)
 51 {
 52     int Size = q[id].size();
 53     while(Size--)
 54     {
 55         node now = q[id].front();
 56         q[id].pop();
 57 
 58         if(vis[!id][now.status])
 59             return now.status;
 60 
 61         int x = now.loc/3;
 62         int y = now.loc%3;
 63         for(int i = 0; i<4; i++)
 64         {
 65             int xx = x + dir[id][i][0];
 66             int yy = y + dir[id][i][1];
 67             if(xx>=0 && xx<=2 && yy>=0 && yy<=2)
 68             {
 69                 node tmp = now;
 70                 tmp.s[x*3+y] = tmp.s[xx*3+yy];
 71                 tmp.s[xx*3+yy] = 9;
 72                 tmp.status = cantor(tmp.s);
 73                 if(!vis[id][tmp.status])
 74                 {
 75                     vis[id][tmp.status] = 1;
 76                     tmp.loc = xx*3+yy;
 77                     path[id][tmp.status] = op[id][i];
 78                     pre[id][tmp.status] = now.status;
 79                     q[id].push(tmp);
 80                 }
 81             }
 82         }
 83     }
 84     return -1;
 85 }
 86 
 87 int solve(node now)     //把两个bfs缩在一起写， 精简代码
 88 {
 89     ms(vis,0);
 90     while(!q[0].empty()) q[0].pop();
 91     while(!q[1].empty()) q[1].pop();
 92 
 93     now.status = cantor(now.s);
 94     pre[0][now.status] = -1;
 95     vis[0][now.status] = 1;
 96     q[0].push(now);
 97 
 98     for(int i = 0; i<9; i++)
 99         now.s[i] = i+1;
100     now.loc = 8;
101     now.status = cantor(now.s);
102     pre[1][now.status] = -1;
103     vis[1][now.status] = 1;
104     q[1].push(now);
105 
106     int time = 0, ret;
107     while(!q[0].empty() ||!q[1].empty())
108     {
109         ret = bfs(0);
110         if(ret!=-1) return ret;
111         ret = bfs(1);
112         if(ret!=-1) return ret;
113         time++;
114     }
115     return -1;
116 }
117 
118 void Print1(int status) //输出正方向的路径
119 {
120     if(pre[0][status]==-1) return;
121     Print1(pre[0][status]);
122     putchar(path[0][status]);
123 }
124 
125 void Print2(int status) //输出反方向的路径
126 {
127     if(pre[1][status]==-1) return;
128     putchar(path[1][status]);
129     Print2(pre[1][status]);
130 }
131 
132 int main()
133 {
134     char tmp[50];
135     while(gets(tmp))
136     {
137         node beg;
138         int cnt = 0;
139         for(int i = 0; tmp[i]; i++)
140         {
141             if(tmp[i]==' ') continue;
142             if(tmp[i]=='x') beg.s[cnt] = 9, beg.loc = cnt++;
143             else  beg.s[cnt++] = tmp[i]-'0';
144         }
145         int status = solve(beg);
146         if(status==-1)
147             puts("unsolvable");
148         else
149         {
150             Print1(status); Print2(status);   //输出路径
151             putchar('\n');
152         }
153     }
154 }
View Code


代码四：一个队列（将正反两方向的结点都丢进同一个队列， 保证了“你一步我一步”）， 一段BFS。

  1 #include <iostream>
  2 #include <cstdio>
  3 #include <cstring>
  4 #include <cmath>
  5 #include <algorithm>
  6 #include <vector>
  7 #include <queue>
  8 #include <stack>
  9 #include <map>
 10 #include <string>
 11 #include <set>
 12 #define ms(a,b) memset((a),(b),sizeof((a)))
 13 using namespace std;
 14 typedef long long LL;
 15 const int INF = 2e9;
 16 const LL LNF = 9e18;
 17 const int MOD = 1e9+7;
 18 const int MAXN = 1e6+10;
 19 
 20 struct node
 21 {
 22     int status;
 23     int s[9];
 24     int loc;
 25     int id; //id标记正反方向
 26 };
 27 
 28 int fac[9] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320};
 29 int dir[2][4][2] = { -1,0, 1,0, 0,-1, 0,1,   0,1, 0,-1, 1,0, -1,0};  //正方向
 30 char op[2][4] = {'u', 'd', 'l', 'r' ,   'l', 'r', 'u', 'd'  };
 31 
 32 char path[2][MAXN];
 33 int pre[2][MAXN];
 34 
 35 int cantor(int s[])
 36 {
 37     int sum = 0;
 38     for(int i = 0; i<9; i++)
 39     {
 40         int num = 0;
 41         for(int j = i+1; j<9; j++)
 42             if(s[j]<s[i])
 43                 num++;
 44         sum += num*fac[8-i];
 45     }
 46     return sum+1;
 47 }
 48 
 49 queue<node>que;
 50 int vis[2][MAXN];
 51 int bfs(node now)     //把两个bfs缩在一起写， 精简代码
 52 {
 53     ms(vis,0);
 54     while(!que.empty()) que.pop();
 55 
 56     now.status = cantor(now.s);
 57     now.id = 0;
 58     pre[0][now.status] = -1;
 59     vis[0][now.status] = 1;
 60     que.push(now);
 61 
 62     for(int i = 0; i<9; i++)
 63         now.s[i] = i+1;
 64     now.loc = 8;
 65     now.status = cantor(now.s);
 66     now.id = 1;
 67     pre[1][now.status] = -1;
 68     vis[1][now.status] = 1;
 69     que.push(now);
 70 
 71     while(!que.empty())
 72     {
 73         node now = que.front();
 74         que.pop();
 75 
 76         if(vis[!now.id][now.status])
 77             return now.status;
 78 
 79         int x = now.loc/3;
 80         int y = now.loc%3;
 81         for(int i = 0; i<4; i++)
 82         {
 83             int xx = x + dir[now.id][i][0];
 84             int yy = y + dir[now.id][i][1];
 85             if(xx>=0 && xx<=2 && yy>=0 && yy<=2)
 86             {
 87                 node tmp = now;
 88                 tmp.s[x*3+y] = tmp.s[xx*3+yy];
 89                 tmp.s[xx*3+yy] = 9;
 90                 tmp.status = cantor(tmp.s);
 91                 if(!vis[now.id][tmp.status])
 92                 {
 93                     vis[now.id][tmp.status] = 1;
 94                     tmp.loc = xx*3+yy;
 95                     path[now.id][tmp.status] = op[now.id][i];
 96                     pre[now.id][tmp.status] = now.status;
 97                     que.push(tmp);
 98                 }
 99             }
100         }
101     }
102 }
103 
104 void Print1(int status) //输出正方向的路径
105 {
106     if(pre[0][status]==-1) return;
107     Print1(pre[0][status]);
108     putchar(path[0][status]);
109 }
110 
111 void Print2(int status) //输出反方向的路径
112 {
113     if(pre[1][status]==-1) return;
114     putchar(path[1][status]);
115     Print2(pre[1][status]);
116 }
117 
118 int main()
119 {
120     char tmp[50];
121     while(gets(tmp))
122     {
123         node beg;
124         int cnt = 0;
125         for(int i = 0; tmp[i]; i++)
126         {
127             if(tmp[i]==' ') continue;
128             if(tmp[i]=='x') beg.s[cnt] = 9, beg.loc = cnt++;
129             else  beg.s[cnt++] = tmp[i]-'0';
130         }
131         int status = bfs(beg);
132         if(status==-1)
133             puts("unsolvable");
134         else
135         {
136             Print1(status); Print2(status);   //输出路径
137             putchar('\n');
138         }
139     }
140 }
View Code

 


 




 

转载于:https://www.cnblogs.com/DOLFAMINGO/p/7538585.html

alince20008
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
POJ2485Highways——JAVA版
09-18
The island nation of Flatopia is perfectly flat. Unfortunately, Flatopia has no public highways. So the traffic is difficult in Flatopia. The Flatopian government is aware of this problem....
POJ 1077 算法
08-09
标题中的“POJ 1078 算法”指的是北京大学在线判题系统（Problem Online Judge，简称POJ）中的第1077题，这通常是一个编程竞赛或者算法练习题目。POJ是一个供程序员练习算法、提交代码并获取运行结果的平台，主要...
Eight POJ - 1077（经典双向BFS八数码）
leekerian的博客
08-05 285
题意 就是问你怎么走可以最后走成：1 2 3 4 5 6 8 x 的状态 思路 由于起点和终点已经知道所以可以用双向bfs，我们考虑bfs的树状图形 我们可以看到阴影部分的地方就是无用的地方，我们双向搜索的话，肯定能找到相同的一层！（注意这里是一层），所以我们双向bfs的策略就是：你走一层，我走一层，这样相会的时候就是路径最短的时候，因为层数相当于步数！至于路劲的问题就很简单了，用pr...
poj 1077 Eight(双向bfs)
aqjh9999的博客
05-06 139
题目链接：http://poj.org/problem?id=1077 思路分析：题目要求在找出最短的移动路径，使得从给定的状态到达最终状态。 <1>搜索算法选择：由于需要找出最短的移动路径，所以选择bfs搜索 <2>判重方法： 将空格视为数字9，则可以将状态的集合视为1-9的排列组合的集合，根据康托展开，将每一个状态映射到一个正整数中； 在由哈希...
poj 1077（双向bfs）--- 未完待续
积少成多，水滴石穿
01-24 161
题目连接：http://poj.org/problem?id=1077 双向bfs： 参考文章：https://blog.csdn.net/DOLFAMINGO/article/details/77855491 前置知识：康拓展开 因为如果暴力搜索的话复杂度为9！，而时间只有1000ms，一定会T，所以这里可以利用双向bfs，当找到终点时结束。 代码： #include ...
POJ1915 BFS&双向BFS
weixin_34191845的博客
05-28 87
俩月前写的普通BFS #include <cstdio> #include <iostream> #include <cstring> #include <queue> using namespace std; int CAS,sx,sy,k,ex,ey,vis[305][305],xx[]={1,-1,2,-2,1,-1,2...
POJ - 1077 Eight : 八数码 -- 哈唏 康托展开 双向bfs A* IDA*
duaduac.com
07-21 940
前言 做完这道题，感觉整个人都完整了。 这道题所能涉及到的知识点特别多，列举如下： STL判重 Hash判重 康托展开 双向bfs A* IDA* 每一种知识点分别对应不同的版本，下面的题解按照以上顺序给出各个版本。 另外有个比较好的博客，可以根据这个博客给出的顺序一步一步实现代码，再此感谢此大牛博主。 点此转到 -> 八数码的八境界http:/
poj 1077 Eight.md
11-17
poj 1077 Eight.md
NOI2002.rar_NOI 2002 dragon_poj bfs
09-14
标题中的“NOI2002.rar_NOI 2002 dragon_poj bfs”提到了几个关键元素：NOI（全国青少年信息学奥林匹克），2002年赛事，dragon问题，以及poj_bfs。这表明我们即将讨论的是2002年全国青少年信息学奥林匹克竞赛中的...
POJ1426-Find The Multiple【BFS+同余模】
07-31
【标题】"POJ1426-Find The Multiple【BFS+同余模】"是一道来源于北京大学在线编程平台POJ的算法题目，主要涉及到了广度优先搜索（BFS）与同余模运算的知识点。这道题目要求解决的是寻找一个整数的倍数问题，可能...
POJ 1915_双向BFS
A_Bo的博客
04-15 397
前提使用双向BFS前提是：我们要知道起点和终点的位置，并且这个题要使用BFS求解我们分别从起点和终点开始进行BFS，以起点开始的BFS的将标记数组记为1，以终点开始的BFA标记数组为2，那么当起点的BFS遇到标记为2的点时或者终点为起点的BFS遇到标记为1的点时我们就找到了答案，答案就是两边步数的相加......双向BFS的基本思路是这样的.....下面试程序的实现：#include &lt;io...
poj1915~双向bfs和bfs
DrawnBreak
08-26 636
这题说是可以用双向bfs，为了看看双向到底能多牛，我做了单向和单向第一个图是单向bfs所花的时间：第二个图是双向bfs所花的时间感觉……没啥特别大的区别啊^而且双向写起来有点麻烦，我写的时候漏了好多东西直接上双向的代码好了，这个双向还是好理解的，#include&lt;iostream&gt; #include&lt;string&gt; #include&lt;queue&gt; #de...
poj 2243 bfs（172ms）或者双向bfs（94ms）
老铁,干了这碗algorithms的博客
03-08 178
点击打开链接普通bfs：//八方向bfs #include &lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;queue&gt; #include&lt;cstring&gt; using namespace std; const int maxn=10; typedef pair&lt;int,int&gt;PII; PII start,en...
Poj1077(bfs,排列散列)
Feynman1999的博客
04-26 293
problem 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 x 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 5 6 7 8 5 6 7 8 5 6 7 8 5 6 7 8 9 x 10 12 9 10...
poj-1077（bfs+康托展开）
weixin_45732455的博客
03-18 300
原题链接http://poj.org/problem?id=1077 大概题意就是把你输入的九宫格变成目标九宫格（大概小时候都玩过这种游戏，复原九宫格），然后输出每次移动的方向。不了解康托展开的可以百度一下，对全排列的判重很有用。提交的时候c++一直超时，改来改去还是不行，改成g++就ac了，郁闷。 代码如下（附有题解） #include<iostream> #include<q...
POJ 1077 Eight（BFS）
jinghui_7的博客
12-17 353
Description The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, a
POJ1077 Eight —— 正向BFS
alince20008的博客
09-05 108
主页面：http://www.cnblogs.com/DOLFAMINGO/p/7538588.html 代码一：以数组充当队列，利用结构体中的pre追溯上一个状态在数组（队列）中的下标： 1 #include <iostream> 2 #include <cstdio> 3 #include <cstrin...
HDU 1043 Eight（经典八数码问题）对比POJ 1077（bfs）
Must so
07-06 811
题目链接：点击打开链接 事情是这样的，我先在TLE无数发之后A了POJ的1077，然后在VJ上看到“原题”，然而，此原题被我TLE5发MLE9发，最后从学长那里学得记录路径的方法之后才过，却原来，这道所谓原题并非原题！！！HDU 的1043和POJ的1077都叫Eight,但是由于HDU上是多组数据POJ上单组，所以POJ上直接正常bfs搜索， HDU上则需要预处理。。。 方法是一样的
poj 1077 (康托展开+bfs)
Avalon_cc的博客
04-13 226
这是一个八数码问题，正好学习了康托展开，就做了这题，和hdu1043很像。康托展开并不难理解，其实就是一种hash。先上模板方便以后自己看。康托展开：int Contor(int str[],int n) { int ans = 0; for(int i = 0; i &lt; n; i++) { int cnt = 0; for(int j...
请帮我分析一下poj 2503 Babelfish——字典映射的思路
最新发布
03-21
好的，对于POJ 2503 Babelfish这道题目，我们可以采用哈希表来实现字典映射。具体思路如下： 1. 首先，我们需要读入一些单词对，每个单词对包含一个外语单词和一个英语单词，它们之间是一一对应的关系。 2. 接下来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值