P1649 [USACO07OCT]障碍路线Obstacle Course

P1649 [USACO07OCT]障碍路线Obstacle Course

N*N(1<=N<=100)方格中，’x’表示不能行走的格子，’.’表示可以行走的格子。卡门很胖，故而不好转弯。现在要从A点走到B点，请问最少要转90度弯几次？

---

调试日志： 左移写成右移了QAQ

---

Solution

正解应该是 \(bfs\) 吧， 每个状态保存 坐标， 步数， 方向， 搜索即可
偏不想正解， 哼
众所周知， 肥宅不可能来回踱步
因为 这样多了两步转向显然不优， 在前一步换个方向到只用一步
所以每个点分裂成两个点， 一个横向的一个纵向的
横向点之间连边， 权值为 \(0\) ， 代表不需要转向
纵向点之间连边， 权值为 \(0\) ， 代表不需要转向
自己的横向点到纵向点连边， 权值为 \(1\) ， 代表转个向花费一
起点可以自由选择横向， 纵向， 到终点时状态横向纵向皆可
所以初始把横纵两种状态作为起始点， 最后看终点横纵状态那个最短路长度小即可

Code

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#define LL long long
#define REP(i, x, y) for(int i = (x);i <= (y);i++)
using namespace std;
int RD(){
    int out = 0,flag = 1;char c = getchar();
    while(c < '0' || c >'9'){if(c == '-')flag = -1;c = getchar();}
    while(c >= '0' && c <= '9'){out = out * 10 + c - '0';c = getchar();}
    return flag * out;
    }
const int maxn = 100019,INF = 1e9 + 19;
int head[maxn],nume = 1;
struct Node{
    int v,dis,nxt;
    }E[maxn << 3];
void add(int u,int v,int dis){
    E[++nume].nxt = head[u];
    E[nume].v = v;
    E[nume].dis = dis;
    head[u] = nume;
    }
int len;
int map[119][119], s, t;
int mx[4] = {0, 0, 1,-1};
int my[4] = {1,-1, 0, 0};
int id(int x, int y){return (x - 1) * len + y;}
bool judge(int x, int y){
    if(x < 1 || x > len || y < 1 || y > len)return 0;
    return 1;
    }
int d[maxn];
bool inq[maxn];
void SPFA(){
    queue<int>Q;
    d[s << 1] = d[s << 1 | 1] = 0;
    Q.push(s << 1), Q.push(s << 1 | 1);
    inq[s << 1] = inq[s << 1 | 1] = 1;
    while(!Q.empty()){
        int u = Q.front();Q.pop();inq[u] = 0;
        for(int i = head[u];i;i = E[i].nxt){
            int v = E[i].v, dis = E[i].dis;
            if(d[u] + dis < d[v]){
                d[v] = d[u] + dis;
                if(!inq[v])Q.push(v), inq[v] = 1;
                }
            }
        }
    }
int main(){
    len = RD();
    REP(i, 1, len)REP(j, 1, len){
        int now = id(i, j);
        d[now << 1] = d[now << 1 | 1] = INF;
        char ss[19];
        scanf("%s", ss);
        if(ss[0] == '.')map[i][j] = 1;
        else if(ss[0] == 'A')map[i][j] = 1, s = now;
        else if(ss[0] == 'B')map[i][j] = 1, t = now;
        }
    REP(i, 1, len)REP(j, 1, len){
        if(!map[i][j])continue;
        int u = id(i, j);
        add(u << 1, u << 1 | 1, 1);
        add(u << 1 | 1, u << 1, 1);
        REP(k, 0, 1){
            int nx = i + mx[k], ny = j + my[k];
            if(!judge(nx, ny) || !map[nx][ny])continue;
            int v = id(nx, ny);
            add(u << 1, v << 1, 0);
            }
        REP(k, 2, 3){
            int nx = i + mx[k], ny = j + my[k];
            if(!judge(nx, ny) || !map[nx][ny])continue;
            int v = id(nx, ny);
            add(u << 1 | 1, v << 1 | 1, 0);
            }
        }
    SPFA();
    int ans = min(d[t << 1], d[t << 1 | 1]);
    if(ans == INF){puts("-1");return 0;}
    printf("%d\n", ans);
    return 0;
    }