poj 3593 Sea Base Exploration

状态压缩DP + 优先队列BFS

题意：给一个矩阵图，图中只有一个*表示起点，#表示不能到达的点，从A开始有k个大写字母（一定是连续的前k个，但是每个字母的个数不一定），一种大写字母表示一种矿石，一个矿石有两个值ai，bi，表示收集这个矿石需要ai电量，另外，在一个矿石点，可以选择收集或者不收集直接走掉，收集后每走一步，需要多加bi的电量，一开始没有任何矿石，每走一步需要1电量，另外，一开始给你P电量。走的方向是上下左右四个方向。你的任务是在电量用完之前，收集到每种矿石（每种矿石只需要1个），然后回到起点，但是注意一点，在没有收集完之前，不能回到起点，因为一旦回到起点就会瞬间传送回基地。如果有的矿石收集不到，或者没足够的电量回到起点，输出Impossible，否则输出最小花费

 

一看这题，没什么特别的方法，那就只好搜索了，因为要求最小花费，所以用优先队列可以达到这个效果，另外搜索过程需要剪枝。

队列中元素的定义

1.当前位置

2.当前收集了哪些矿石

3.当前花费

对于当前收集了哪些矿石，因为矿石种类最大是10，所以可以用状态压缩，用一个长度为k的01串来表示哪些矿石被搜集了哪些没有，然后压缩为一个十进制数

状态的转移就是枚举四个方向，然后计算新的位置和花费，以及新的收集情况

关于收集和不收集矿石

收集的话比较容易，就是当前点有矿石，并且还没有收集到这个矿石，就可以考虑收集（但不是一定要收集）

不收集矿石有几种情况

当前点是个自由地.，不存在矿石，当然不能收集；当前地有矿石，但是已经有这种矿石了，那肯定不收集；当前点有矿石，而且还没收集到这个矿石，也是可以选择不收集的，因为可能这种矿石不止一个，可以去别的地方再收集

但是这些情况也没什么特别要注意的地方，只是说，要有这个意识，要考虑到这些情况

 

最重要的是剪枝

BFS搜索，要达到剪枝效果，最好就是入队时设置较严格的条件，防止元素重复入队。

剪枝主要靠一个数组vis[x][y][s]，表示点（x，y）的收集情况为s，这个状态是否被搜索过，如果搜索给，不用再入队，每个这样的状态只会入队一次

为什么这样剪枝是对的。因为我们用的是优先队列，是按电量花费最小这种悠闲级出队的，那么可以知道，对于一个状态[x,y,s]，如果第一次被搜索到，那么它的电量花费是最少的，以后再搜索到这个状态，电量花费不会比第一次的更少，所以没必要进来。

另外仿照无限搜索下去的关键是，对于一个新的状态，如果要达到这个状态需要的电量超过了总电量，那么这个状态不应该入队

再者就是，在得到一个合法的新状态后，先看看它是不是我们的目标状态，是的话直接返回答案

最后一点，就是注意题意，不能起点不能随便走的，一旦回到起点就会传送回基地相当于一切都终止了，所以如果一个新状态的位置是起点，但是还没有搜集到全部矿石，那么这个状态是要丢弃的，因为这个状态如果入队了，说明允许了这个操作，允许在没有收集完矿石的条件下回到起点，这和题意是相矛盾的

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;
#define N 25
#define M 15
#define NS 2510
const int dx[4] = {-1,1,0,0};
const int dy[4] = {0,0,-1,1};

char map[N][N];
int row,col,kind,power,sx,sy,tot;
int A[M],B[M],per[NS];
bool vis[N][N][NS];
struct node  //bfs搜索时的状态
{
    int x,y;    //当前所在的坐标
    int s;     //携带的物品的状态，压缩回来的十进制数
    int cost;  //花费了多少电量
    void func(int xx ,int yy ,int ss ,int cc)
    { x=xx; y=yy; s=ss; cost=cc; }
    bool operator<(const struct node &a) const{ 
        return cost > a.cost; }
};
priority_queue<struct node>que;


void input()
{
    cin >> row >> col >> kind >> power;
    for(int r=0; r<row; r++) cin >> map[r];
    for(int i=0; i<kind; i++) cin >> A[i] >> B[i];
    for(int r=0; r<row; r++)
        for(int c=0; c<col; c++)
            if(map[r][c] == '*')
            { sx=r; sy=c; break; }
}

void cal_per()
{//计算在每种状态下，走一步需要的花费，先预先计算，不必一边搜索一边计算
//    memset(per,0,sizeof(per));
    tot = (1<<kind);
    for(int s=0; s<tot; s++)
    {
        per[s] = 1;
        for(int k=0; k<kind; k++)
            if( s & (1<<k) )
                per[s] += B[k];
    }
}

int solve()
{
    struct node a,b;
    memset(vis,0,sizeof(vis));
    while(!que.empty()) que.pop();
    a.func(sx,sy,0,0);
    que.push(a);
    vis[sx][sy][0] = true;
    //剪枝：用vis数组标记，另外，电量>power的不能入队
    //得到一个新状态，先判断它是否是目标状态，是的话直接返回答案，不用入队
    while(!que.empty())
    {
        a = que.top(); que.pop();
        if(a.cost + per[a.s] > power) continue; //当前电量，无论怎么走都会超过power，那么直接丢弃
        for(int k=0; k<4; k++) //四个方向
        {
            int xx = a.x + dx[k];
            int yy = a.y + dy[k];
            int ss = a.s;
            int cc = a.cost + per[a.s];
            if(xx<0 || xx>=row || yy<0 || yy>=col || map[xx][yy]=='#') continue; //不是合法的位置

            if(xx==sx && yy==sy) 
                if(ss == tot-1) return cc;//目标状态
                else            continue; //回到起点又没有收集完矿石，肯定是多余的（走回头路），直接抛弃
            
            if(!vis[xx][yy][ss]) //这个状态没搜索过
            {//在这个地方不采集矿石，而不采集是有很多可能的
                b.func(xx,yy,ss,cc);
                que.push(b);
                vis[xx][yy][ss] = true;
            }

            if(map[xx][yy]>='A' && map[xx][yy]<='Z') //有矿石
            {
                int index = map[xx][yy] - 'A';
                if( !(ss & (1<<index)) ) //没有这个矿石,考虑采集
                {
                    ss |= (1<<index); //采集后的状态
                    cc += A[index];   //采集的花费
                    if(cc+A[index] > power)  continue; //超过电量，放弃
                    if(xx==sx && yy==sy && ss==tot-1) return cc; //目标状态
                    if(!vis[xx][yy][ss])
                    {
                        b.func(xx,yy,ss,cc);
                        que.push(b);
                        vis[xx][yy][ss] = true;
                    }
                }
            }
        }
    }
    return -1;
}

int main()
{
    int cas;
    cin >> cas;
    while(cas--)
    {
        input();
        cal_per();
        int res = solve();
        if(res == -1) cout << "Impossible" << endl;
        else          cout << res << endl;
    }
    return 0;
}