【题解】APIO2013机器人

　　其实这题前前后后的思考时间加起来应该有两天之久了，dp状态，转移方式等等都还是比较好想，然而左看右看觉得spfa复杂度未免太爆炸……然后选择看了一篇题解，发现在多重优化之下，其实是可以过的……

　　首先建立状态，这个应该比较明显：\(f[l][r][x][y]\) 代表合并完区间 \(l\) ~\(r\) 之后，机器人停在 \(x,y\) 处所需要的最少移动次数。转移状态即为：

　　\(f[l][r][x][y] = f[l][k][x][y] + f[k + 1][r][x][y] \left ( l <= k <= r \right )\)

\(f[l][r][x][y] = f[l][r][x'][y'] + 1 \)

　　其中第二个转移发生的条件是 \(x',y'\) 可以一步到达 \(x,y\)。第二个转移状态就是在之前的博客中所提及的那样：1.满足三角形不等式；2.不满足拓扑序；针对这样的转移，我们用 spfa 来优化 dp 的转移。注意在这张图中，边权均为1。在单源的最短路中，这样的图spfa可以优化为bfs， 在多源最短路中我们可以使用两个队列来进行优化。这两个队列分别存储新增的节点 & 被松弛所以要去松弛其余节点的节点。这样将节点分类之后，每一次取出队首元素权值更小的进行松弛操作。我们会发现第二个队列中节点的权值是单调的（在边权为1的图中，先访问到的节点权值更小），而第一个队列中的元素我们使用基数排序来排。（并不知道为什么要用基数排序，或许就是比较快吧？）

　　然后这份代码是我抄的大佬的代码，非常感谢了。其中有一个小小的技巧：memset的时候默认赋给节点当前数据类型的最大值，相加会溢出。但对于这种没有正负要求的，我们可以利用 unsigned 自然溢出使得结果依然是最大值。(･ω<)☆ 感觉这题还是挺毒的，差点就被毒死了……

#include <bits/stdc++.h>
using namespace std;
#define maxn 505
#define maxk 400000
#define uns unsigned short
#define INF 32639
int n, W, H, ans = INF;
int mark[maxn][maxn][];
int L, R;
uns f[][][maxn][maxn];
int cnt, top, tank[maxk], S[maxk];
char Map[maxn][maxn];
bool vis[maxn][maxn];
int dxy[][] = {{,}, {,}, {,-}, {-,}};

struct node
{
    int x, y;
    node(int xx = , int yy = ) { x = xx, y = yy; }
}g[maxn][maxn][], pos[], q[maxk];
queue <node> q1, q2;

int read()
{
    int x = , k = ;
    char c;
    c = getchar();
    while(c < '' || c > '') { if(c == '-') k = -; c = getchar(); }
    while(c >= '' && c <= '') x = x *  + c - '', c = getchar();
    return x * k;
}

void gmin(uns &x, uns y) { x = x > y ? y : x; }

node dfs(int x, int y, int k)
{
    if(mark[x][y][k] == cnt) return g[x][y][k] = node (-, -);
    mark[x][y][k] = cnt;
    if(g[x][y][k].x !=  && g[x][y][k].y != ) return g[x][y][k];
    int pre = k;
    if(Map[x][y] == 'A') k = (k + ) % ;
    else if(Map[x][y] == 'C') k = (k + ) % ;
    int xx = x + dxy[k][], yy = y + dxy[k][];
    if(xx <  || yy <  || xx > H || yy > W || Map[xx][yy] == 'x') return g[x][y][pre] = node(x, y);
    return g[x][y][pre] = dfs(xx, yy, k);
}

void spfa()
{
    memset(tank, , sizeof(tank));
    for(int i = ; i <= top; i ++) tank[f[L][R][q[i].x][q[i].y]] ++;
    for(int i = ; i <= INF; i ++) tank[i] += tank[i - ];
    for(int i = ; i <= top; i ++) S[tank[f[L][R][q[i].x][q[i].y]] --] = i;
    for(int i = ; i <= top; i ++) q1.push(q[S[i]]);
    top = ;
    while(!q1.empty() || !q2.empty())
    {
        node now;
        if(q1.empty()) now = q2.front(), q2.pop();
        else if(q2.empty()) now = q1.front(), q1.pop();
        else
        {
            int x1 = q1.front().x, y1 = q1.front().y;
            int x2 = q2.front().x, y2 = q2.front().y;
            if(f[L][R][x1][y1] <= f[L][R][x2][y2]) now = q1.front(), q1.pop();
            else now = q2.front(), q2.pop();
        }
        vis[now.x][now.y] = ;
        for(int i = ; i < ; i ++)
        {
            node v = g[now.x][now.y][i];
            if(v.x == - || v.y == -) continue;
            if(f[L][R][v.x][v.y] > f[L][R][now.x][now.y] + )
            {
                f[L][R][v.x][v.y] = f[L][R][now.x][now.y] + ;
                if(!vis[v.x][v.y]) vis[v.x][v.y] = , q2.push(v);
            }
        }
    }
}

int main()
{
    n = read(), W = read(), H = read();
    memset(f, , sizeof(f));
    for(int i = ; i <= H; i ++)
    {
        scanf("%s", Map[i] + );
        for(int j = ; j <= W; j ++)
            if(Map[i][j] > '' && Map[i][j] <= '')
                pos[Map[i][j] - ''] = node(i, j);
    }
    for(int i = ; i <= H; i ++)
        for(int j = ; j <= W; j ++)
            if(Map[i][j] != 'x')
                for(int k = ; k < ; k ++)
                    ++ cnt, dfs(i, j, k);
    for(int i = ; i <= n; i ++)
    {
        vis[pos[i].x][pos[i].y] = ;
        q[++ top] = pos[i];
        L = R = i; f[i][i][pos[i].x][pos[i].y] = ;
        spfa();
    }
    for(int l = , j; l <= n; l ++)
        for(int i = ; (j = i + l - ) <= n; i ++)
        {
            for(int x = ; x <= H; x ++)
                for(int y = ; y <= W; y ++)
                {
                    for(int k = i; k < j; k ++)
                        gmin(f[i][j][x][y], f[i][k][x][y] + f[k + ][j][x][y]);
                    if(f[i][j][x][y] < INF) q[++ top] = node(x, y), vis[x][y] = ;
                }
            L = i, R = j; spfa();
        }
    unsigned short ans = INF;
    for(int i = ; i <= H; i ++)
        for(int j = ; j <= W; j ++)
            ans = min(ans, f[][n][i][j]);
    if(ans < INF) printf("%u\n", ans);
    else printf("-1\n");
    return ;
}