多校训练2 I Penguins BFS

找最短路径，采用bfs
要求输出最小字典序，则对路径搜索的方向顺序进行固定，保证D<L<R<U

在设置无效操作和四个方向时，要特别注意企鹅 1 和 2 的镜像性。
且注意题目的x, y（行、列）建立是x向上递减， y向左递减，x, y与四个操作的关系，D(1, 0), L(0,-1),R(0, 1),U(-1, 0)。

其余分析在代码注释中

accode:

#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
const int n = 20; 

char v[] = {'S','D', 'L', 'R', 'U'};//只使用后四个 
char mp1[n+1][n+1], mp2[n+1][n+1];
//一个无效操作和四个方向 (注意坐标建立与平常时不同，顺序为 D L R U )
//注意1 2镜像 
int xx1[] = {0, 1,  0, 0, -1};
int yy1[] = {0, 0, -1, 1,  0}; 
int xx2[] = {0, 1,  0, 0, -1};
int yy2[] = {0, 0, 1, -1,  0}; 
//建立一个四维数组标记当前状态是否已经访问过
bool vis[n+1][n+1][n+1][n+1];//前两维为企鹅 1状态，后两维为企鹅 2状态 

//用结构体保存当前位置，当前走过的步数，走到该位置用成员数组保存一整段经过的"LULD"操作 
struct node{
    int lx, ly, rx, ry, step, st[410]; 
}; 

void init()
{
    for(int i = 0; i <= n; i++)
        for(int j = 0; j <= n; j++)
            for(int k = 0; k <= n; k++)
                for(int l = 0; l <= n; l++)
                    vis[i][j][k][l] = 0;
}

void print(node k)
{
    node now, next;
    now.lx = n, now.ly = n, now.rx = n, now.ry = 1;
    mp1[n][n] = 'A', mp2[n][1] = 'A';
    for(int i = 1; i <= k.step ; i++)
    {
        next = now;
        //判断每一步对于两只企鹅来说是否是无效操作，判断方式为用next信息进行分析 
        bool f1 = 0, f2 = 0;
        int dx1 = now.lx + xx1[k.st[i]], dy1 = now.ly + yy1[k.st[i]];
        int dx2 = now.rx + xx2[k.st[i]], dy2 = now.ry + yy2[k.st[i]];
        if(dx1 <= 0 || dx1 > n || dy1 <= 0 || dy1 > n || mp1[dx1][dy1] == '#')
        {
            f1 = 1;
        }
        if(dx2 <= 0 || dx2 > n || dy2 <= 0 || dy2 > n || mp2[dx2][dy2] == '#')
        {
            f2 = 1;
        }
        if(f1 + f2 == 2)
            continue;
        else if(f1 == 1)//更新企鹅 2信息 
        {
            next.rx = dx2, next.ry = dy2;
        }
        else if(f2 == 1)
        {
            next.lx = dx1, next.ly = dy1;
        }
        else
        {
            next.lx = dx1, next.ly = dy1;
            next.rx = dx2, next.ry = dy2;
        }
        mp1[next.lx][next.ly] = 'A';
        mp2[next.rx][next.ry] = 'A';
        now = next;        
    }        
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= n; j++)
            cout<<mp1[i][j];
        cout<<" ";
        for(int j = 1; j <= n; j++)
            cout<<mp2[i][j];
        cout<<endl;
    }
}

void bfs()
{
    queue<node> q;//队列维护每一步状态 
    node now;//记录当前位置信息 
    now.lx = n, now.ly = n, now.rx = n, now.ry = 1, now.step = 0;
    q.push(now);
    while(!q.empty())
    {
        now = q.front();
        q.pop();
        //到达终点 
        if(now.lx == 1 && now.ly == n && now.rx == 1 && now.ry == 1)
        {
            cout<<now.step<<endl;
            for(int i = 1; i <= now.step; i++)
                    cout<<v[now.st[i]];
            cout<<endl;
            //打印地图(走过的路)
            print(now);
            return;
        }
        else
        {
            node next;//下一个状态 
            for(int i = 1 ; i <= 4; i++)
            {
                next = now;
                int dx1 = now.lx + xx1[i], dy1 = now.ly + yy1[i];
                int dx2 = now.rx + xx2[i], dy2 = now.ry + yy2[i];
                bool f1 = 0, f2 = 0;
                //满足无效操作的条件 (企鹅 1)
                if(dx1 <= 0 || dx1 > n || dy1 <= 0 || dy1 > n || mp1[dx1][dy1] == '#')
                {
                    f1 = 1;
                }
                //对于企鹅 2 
                if(dx2 <= 0 || dx2 > n || dy2 <= 0 || dy2 > n || mp2[dx2][dy2] == '#')
                {
                    f2 = 1;
                }
                //跳过对两只企鹅来说都是无效操作的情况 
                if(f1 == 1 && f2 == 1)
                    continue;
                else if(f1 == 1)//更新企鹅 2信息 
                {
                    next.rx = dx2, next.ry = dy2;
                }
                else if(f2 == 1)
                {
                    next.lx = dx1, next.ly = dy1;
                }
                else
                {
                    next.lx = dx1, next.ly = dy1;
                    next.rx = dx2, next.ry = dy2;
                }
                //局面重复，则不加入队列重复标记 
                if(vis[next.lx][next.ly][next.rx][next.ry])
                    continue;
                //标记
                vis[next.lx][next.ly][next.rx][next.ry] = 1;
                //更新步数
                next.step = now.step + 1;
                //储存当前步数走的方向
                next.st[next.step] = i;
                q.push(next); 
            }
        }
    }
}

int main()
{
    std::ios::sync_with_stdio(false); 
    cin.tie(0), cout.tie(0);
    init();
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= n; j++)
            cin>>mp1[i][j];
        for(int j = 1; j <= n; j++)
            cin>>mp2[i][j];
    }
    
    vis[n][n][n][1] = 1;
    bfs();
    
    return 0;
}