离散化+BFS HDOJ 4444 Walk

题目传送门

 /*
     题意：问一个点到另一个点的最少转向次数。
     坐标离散化+BFS：因为数据很大，先对坐标离散化后，三维(有方向的)BFS
         关键理解坐标离散化，BFS部分可参考HDOJ_1728
 */
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <queue>
 #include <vector>
 #include <map>
 #include <cmath>
 using namespace std;

 const int MAXN =  *  + ;
 const int INF = 0x3f3f3f3f;
 vector<int> nx, ny;
 map<int, int> mx, my;
 struct Point
 {
     int x, y, t, d;
     Point (int _x = , int _y = )    {x = _x, y = _y, t = ;}
     void read(void)
     {
         scanf ("%d%d", &x, &y);
         nx.push_back (x);    ny.push_back (y);
     }
     void updata(void) {x = mx[x];    y = my[y];}
     bool operator < (const Point &r) const    {return t > r.t;}
 }s, e, p[][];
 bool maze[*MAXN][*MAXN];
 int dp[MAXN][MAXN][];
 bool can[MAXN][MAXN][];
 int dx[] = {, , , -};
 int dy[] = {, , -, };
 int w;

 int compress(vector<int> &x, map<int, int> &mp)
 {
     vector<int> xs;
     sort (x.begin (), x.end ());
     x.erase (unique (x.begin (), x.end ()), x.end ());
     for (int i=; i<x.size (); ++i)
     {
         for (int d=-; d<=; ++d)    xs.push_back (x[i] + d);
     }
     sort (xs.begin (), xs.end ());
     xs.erase (unique (xs.begin (), xs.end ()), xs.end ());
     for (int i=; i<xs.size (); ++i)    mp[x[i]] = find (xs.begin (), xs.end (), x[i]) - xs.begin ();
     return xs.size ();
 }

 bool check(Point &a)
 {
     if ( <= a.x && a.x <= w &&  <= a.y && a.y <= w && dp[a.x][a.y][a.d] > a.t)
     {
         dp[a.x][a.y][a.d] = a.t;
         return true;
     }
     return false;
 }

 int BFS(void)
 {
     memset (dp, INF, sizeof (dp));
     priority_queue<Point> Q;    s.t = ;
     for (s.d=; s.d<; ++s.d)
     {
         Q.push (s);    dp[s.x][s.y][s.d] = ;
     }

     while (!Q.empty ())
     {
         Point now = Q.top ();    Q.pop ();
         if (dp[now.x][now.y][now.d] < now.t)    continue;
         if (now.x == e.x && now.y == e.y)    return now.t;
         for (int d=-; d<=; ++d)
         {
             Point to = now;
             to.d = (to.d +  + d) % ;
             if (!can[to.x][to.y][to.d])    continue;
             int x =  * to.x, y =  * to.y;
             if (maze[x][y] && maze[x+][y+] &&
                 ((now.d %  ==  && d != ) || (now.d %  ==  && d != -)))    continue;
             if (maze[x+][y] && maze[x][y+] &&
                 ((now.d %  ==  && d != -) || (now.d %  ==  && d != )))    continue;
             if (d != )    to.t++;
             to.x += dx[to.d];    to.y += dy[to.d];
             if (check (to))    Q.push (to);
         }
     }

     return -;
 }

 int main(void)        //HDOJ 4444 Walk
 {
 //    freopen ("C.in", "r", stdin);

     while (true)
     {
         nx.clear ();    ny.clear ();    mx.clear ();    my.clear ();
         s.read ();    e.read ();
         if (!s.x && !s.y && !e.x && !e.y)    break;
         memset (maze, false, sizeof (maze));

         int n;    scanf ("%d", &n);
         for (int i=; i<=n; ++i)
         {
             Point *t = p[i];
             t[].read ();    t[].read ();
             if (t[].x > t[].x)    swap (t[], t[]);
             if (t[].y > t[].y)
             {
                 Point a = t[], b = t[];
                 t[].y = b.y;    t[].y = a.y;
             }
             t[] = (Point) {t[].x, t[].y};
             t[] = (Point) {t[].x, t[].y};
         }

         w = max (compress (nx, mx), compress (ny, my));
         s.updata ();    e.updata ();
         for (int i=; i<=n; ++i)
         {
             Point *t = p[i];
             for (int j=; j<; ++j)    t[j].updata ();
             for (int j=; j<; ++j)    t[j] = Point (*t[j].x, *t[j].y);
             for (int j=t[].x+; j<=t[].x; ++j)
             {
                 for (int k=t[].y+; k<=t[].y; ++k)    maze[j][k] = true;        //离散化后将矩形涂黑
             }
         }

         memset (can, true, sizeof (can));
         for (int i=; i<w; ++i)
         {
             for (int j=; j<w; ++j)
             {
                 int x = i * , y = j * ;
                 bool *d = can[i][j];
                 if (maze[x][y+] && maze[x+][y+])    d[] = false;        //判断4个方向能不能走
                 if (maze[x+][y] && maze[x+][y+])    d[] = false;
                 if (maze[x][y] && maze[x+][y])    d[] = false;
                 if (maze[x][y] && maze[x][y+])    d[] = false;
             }
         }

         printf ("%d\n", BFS ());
     }

     return ;
 }