bzoj千题计划230：bzoj3205: [Apio2013]机器人

http://www.lydsy.com/JudgeOnline/problem.php?id=3205

历时一天，老子终于把它A了

哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈

因为不懂spfa的优化 以及 数组越界  TAT

┭┮﹏┭┮

牢骚发完了，题解在下面  (⊙o⊙)…

n只有9，很像状压dp

dp[l][r][x][y] 表示在（x，y）位置 合成了x-y复合机器人 的最少推动次数

它的转移 存在后效性

所以上 斯坦纳树

自身的转移：dp[l][r][x][y]=min{dp[l][k][x][y]+dp[k+1][r][x][y]}

互相转移：

预处理出 在（x，y）位置 向4个方向推，最终会停留在哪个位置

可以记忆化搜索

然后用spfa

裸的spfa 得了65

加上SLF优化得了75

再加LLL优化还是75，但慢了一点儿 （可能是我不会用吧TAT）

然后改了双端队列还是75

最后参考了一位大佬的做法：

双端队列优化只是考虑 当前要入队的和在队首的 目前哪个更优

那么可以将这个扩展成单调队列，根noip2017蚯蚓很像

两个队列q1,q2

q2中存放在自身转移中入队的状态，从小到大排好序

然后由q2中转移出的状态，全部放进q1，

因为转移代价是1，q2又单调，所以可以保证q1也是单调的

每次比较q1和q2的队首，取出目前更优的状态 扩展新的状态

#include<queue>
#include<cstdio>
#include<cstring>

using namespace std;

#define N 501

typedef pair<int,int> pii;

#define MP(x,y) make_pair(x,y)

int T,m,n;
char s[N];

int map[N][N];

int dx[]={-,,,};
int dy[]={,,,-};

int pos[][N][N];
bool v[][N][N];

int dp[][][N][N];

int tot,mx;
int cnt[N*N*];
pii tmp[N*N],q[N*N];
queue<pii>q1,q2;

bool vis[N][N];

inline int &min(int &x,int &y) { return x<y ? x: y; }

bool inmap(int x,int y)
{
    if(x<= || x>n || y<= || y>m) return false;
    if(!map[x][y]) return false;
    return true;
}

int find(int x,int y,int d)
{
    if(pos[d][x][y]) return pos[d][x][y];
    if(!map[x][y]) return -;
    if(v[d][x][y]) return -;
    v[d][x][y]=true;
    int nd=d;
    if(map[x][y]==-) nd=(d-+)%;
    if(map[x][y]==-) nd=(d+)%;
    int npos=-;
    if(!inmap(x+dx[nd],y+dy[nd])) npos=-;
    else npos=find(x+dx[nd],y+dy[nd],nd);
    v[d][x][y]=false;
    if(npos==-) return pos[d][x][y]=(x-)*m+y;
    else return pos[d][x][y]=npos;
}

void spfa(int l,int r)
{
      for(int i=;i<=mx;++i) cnt[i]=;
    for(int i=;i<=tot;++i) cnt[dp[l][r][tmp[i].first][tmp[i].second]]++;
    for(int i=;i<=mx;++i) cnt[i]+=cnt[i-];
    for(int i=tot;i;--i) q[cnt[dp[l][r][tmp[i].first][tmp[i].second]]--]=tmp[i];
    for(int i=;i<=tot;++i) q2.push(q[i]);
    int x,y,nx,ny;
    while(!q2.empty() || !q1.empty())
    {
        if(q1.empty())
        {
            x=q2.front().first;
            y=q2.front().second;
            q2.pop();
        }
        else if(q2.empty())
        {
            x=q1.front().first;
            y=q1.front().second;
            q1.pop();
            vis[x][y]=false;
        }
        else if(dp[l][r][q1.front().first][q1.front().second]>dp[l][r][q2.front().first][q2.front().second])
        {
            x=q2.front().first;
            y=q2.front().second;
            q2.pop();
        }
        else
        {
            x=q1.front().first;
            y=q1.front().second;
            q1.pop();
            vis[x][y]=false;
        }
        for(int i=;i<;++i)
        {
            if(pos[i][x][y]==-) continue;
            nx=(pos[i][x][y]-)/m+;
            ny=pos[i][x][y]-(nx-)*m;
            if(dp[l][r][x][y]+<dp[l][r][nx][ny])
            {
                dp[l][r][nx][ny]=dp[l][r][x][y]+;
                if(!vis[nx][ny]) q1.push(MP(nx,ny)),vis[nx][ny]=true;
            }
        }
    }
}

int main()
{
    scanf("%d%d%d",&T,&m,&n);
    for(int i=;i<=n;++i)
    {
        scanf("%s",s+);
        for(int j=;j<=m;++j)
            if(s[j]=='A') map[i][j]=-;
            else if(s[j]=='C') map[i][j]=-;
            else if(s[j]>='' && s[j]<='') map[i][j]=s[j]-'';
            else if(s[j]=='.') map[i][j]=;
    }
    for(int d=;d<;++d)
    {
        for(int i=;i<=n;++i)
            for(int j=;j<=m;++j)
                if(map[i][j]) find(i,j,d);
    }
    memset(dp,,sizeof(dp));
    int oo=dp[][][][];
    for(int i=;i<=n;++i)
        for(int j=;j<=m;++j)
            if(map[i][j]>= && map[i][j]<=) dp[map[i][j]][map[i][j]][i][j]=;
    for(int i=T;i;--i)
        for(int j=i;j<=T;++j)
        {
            tot=mx=;
            for(int x=;x<=n;++x)
                for(int y=;y<=m;++y)
                {
                    for(int k=i;k<j;++k)
                        dp[i][j][x][y]=min(dp[i][j][x][y],dp[i][k][x][y]+dp[k+][j][x][y]);
                    if(dp[i][j][x][y]!=oo) tmp[++tot]=MP(x,y),mx=max(mx,dp[i][j][x][y]);
                }
            if(tot) spfa(i,j);
        }
    int ans=oo;
    for(int i=;i<=n;++i)
        for(int j=;j<=m;++j)
            ans=min(ans,dp[][T][i][j]);
    if(ans==oo) printf("-1");
    else printf("%d",ans);
    return ;
}