hdu 4568 bfs + 状压dp

//这题的数据是不是有问题... 不考虑宝藏一个也拿不到也能AC...

#include "bits/stdc++.h"
using namespace std;
const int INF = 0x3f3f3f3f;
int T;
int N, M;
int mat[210][210];
int K;
int tot_tra, tra[210][210];

//dp parameters
int dis_tra_broder[20], dis_tra_tra[20][20];
int dp[10000][20];

//bfs parameters
struct Node
{
    int row, col;
    int cost;
    bool operator< (const Node &tmp) const
    {
        return cost > tmp.cost;
    }
}now, Next, begin_pos[20];

int dis[210][210];
bool vis[210][210];

inline bool check_border(int row, int col)
{
    if(row == 1 || row == N || col == 1 || col == M) {
        return 1;
    }
    return 0;
}

inline bool check(int row, int col)
{
    if(row < 1 || row > N || col < 1 || col > M) {
        return 0;
    }
    return 1;
}


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

void bfs(int index_tra)
{
    priority_queue<Node> q;
    q.push(begin_pos[index_tra]);
    memset(vis, 0, sizeof(vis));
    memset(dis, INF, sizeof(dis));
    dis[ begin_pos[index_tra].row ][ begin_pos[index_tra].col ] = 0;
    while(!q.empty()) {
        now = q.top();
        q.pop();
        if(vis[now.row][now.col]) {
            continue;
        }
        vis[now.row][now.col] = 1;
        if(tra[now.row][now.col]) {
            dis_tra_tra[index_tra][ tra[now.row][now.col] ] = now.cost;
        }
        if(check_border(now.row, now.col)) {
            dis_tra_broder[index_tra] = min(dis_tra_broder[index_tra], now.cost);
        }
        int i;
        for(i = 0; i < 4; ++i) {
            Next.row = now.row + dx[i];
            Next.col = now.col + dy[i];
            if(check(Next.row, Next.col) && mat[Next.row][Next.col] != -1) {
                Next.cost = now.cost + mat[Next.row][Next.col];
                if(Next.cost < dis[Next.row][Next.col]) {
                    dis[Next.row][Next.col] = Next.cost;
                    q.push(Next);
                }
            }
        }
    }
}

int main()
{
    scanf("%d", &T);
    while(T--) {
        memset(tra, 0, sizeof(tra));
        memset(dis_tra_broder, INF, sizeof(dis_tra_broder));
        memset(dis_tra_tra, INF, sizeof(dis_tra_tra));
        memset(dp, INF, sizeof(dp));
        scanf("%d%d", &N, &M);
        int i, j;
        for(i = 1; i <= N; ++i) {
            for(j = 1; j <= M; ++j) {
                scanf("%d", &mat[i][j]);
            }
        }
        scanf("%d", &K);
        int row, col;
        for(i = 1; i <= K; ++i) {
            scanf("%d%d", &row, &col);
            ++row;
            ++col;
            tra[row][col] = i;
            begin_pos[i].row = row;
            begin_pos[i].col = col;
//            begin_pos[i].cost = 0;
        }
        for(i = 1; i <= K; ++i) {
            bfs(i);
        }
        int tot_s = (1 << K) - 1;
        int s, step_s, u, pre_s, pre_step_s, v;
        for(u = 1; u <= K; ++u) {
            dp[(1 << (u - 1))][u] = dis_tra_broder[u] + mat[begin_pos[u].row][begin_pos[u].col];
        }
        for(s = 3; s <= tot_s; ++s) {
            for(u = 1; u <= K; ++u) {
                step_s = (1 << (u - 1));
                if((s & step_s) && (step_s != s)) {
                    pre_s = s ^ step_s;
                    for(v = 1; v <= K; ++v) {
                        pre_step_s = (1 << (v - 1));
                        if(pre_s & pre_step_s) {
                            dp[s][u] = min(dp[s][u], dp[pre_s][v] + dis_tra_tra[v][u]);
                        }
                    }
                }
            }
        }
        int res = INF;
        for(u = 1; u <= K; ++u) {
            res = min(res, dp[tot_s][u] + dis_tra_broder[u]);
        }
        printf("%d
", res);
    }
}