《算法竞赛进阶指南》2.6广搜变形

175. 电路维修

达达是来自异世界的魔女，她在漫无目的地四处漂流的时候，遇到了善良的少女翰翰，从而被收留在地球上。
翰翰的家里有一辆飞行车。
有一天飞行车的电路板突然出现了故障，导致无法启动。
电路板的整体结构是一个R行C列的网格（R,C≤500），如下图所示。

每个格点都是电线的接点，每个格子都包含一个电子元件。
电子元件的主要部分是一个可旋转的、连接一条对角线上的两个接点的短电缆。
在旋转之后，它就可以连接另一条对角线的两个接点。
电路板左上角的接点接入直流电源，右下角的接点接入飞行车的发动装置。
达达发现因为某些元件的方向不小心发生了改变，电路板可能处于断路的状态。
她准备通过计算，旋转最少数量的元件，使电源与发动装置通过若干条短缆相连。
不过，电路的规模实在是太大了，达达并不擅长编程，希望你能够帮她解决这个问题。

输入格式
输入文件包含多组测试数据。
第一行包含一个整数T，表示测试数据的数目。
对于每组测试数据，第一行包含正整数R和C，表示电路板的行数和列数。
之后R行，每行C个字符，字符是"/“和”"中的一个，表示标准件的方向。

输出格式
对于每组测试数据，在单独的一行输出一个正整数，表示所需的缩小旋转次数。
如果无论怎样都不能使得电源和发动机之间连通，输出NO SOLUTION。

数据范围
1≤R,C≤500,
1≤T≤5

输入样例：

1
3 5
\\/\\
\\///
/\\\\

输出样例：
1

样例解释
样例的输入对应于题目描述中的情况。
只需要按照下面的方式旋转标准件，就可以使得电源和发动机之间连通。

#include <iostream>
#include <algorithm>
#include <deque> 
#include <cstring>

using namespace std;

typedef pair<int, int> PII;
const int N = 510;

int n, m; //长和宽
char g[N][N]; //图
int d[N][N]; //距离

int bfs()
{
    memset(d, 0x3f, sizeof d); //把所有距离赋值正无穷
    
    deque<PII> dq; //双端队列
    dq.push_back({0, 0});
    d[0][0] = 0;
    
    int dx[4] = {-1, -1, 1, 1}, dy[4] = {-1, 1, 1, -1};
    int ix[4] = {-1, -1, 0, 0}, iy[4] = {-1, 0, 0, -1};
    char cs[] = "\\/\\/";
    
    while(dq.size())
    {
        auto t = dq.front();
        dq.pop_front();
        
        int x = t.first, y = t.second;
        for(int i = 0; i < 4; i ++)
        {
            int a = x + dx[i], b = y + dy[i];
            if(a >= 0 && a <= n && b >= 0 && b <= m)
            {
                int w = 0; 
                int j = x + ix[i], k = y + iy[i];
                if(g[j][k] != cs[i]) w = 1;
                
                if(d[a][b] > d[x][y] + w)
                {
                    d[a][b] = d[x][y] + w;
                    if(w) dq.push_back({a, b});
                    else dq.push_front({a, b});
                }
            }
        }
    }
    if(d[n][m] == 0x3f3f3f3f) return -1;
    return d[n][m];
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T --)
    {
        scanf("%d%d", &n, &m);
        for(int i = 0; i < n; i ++) scanf("%s", g[i]);
        
        
        int t = bfs();
        if(t == -1) puts("NO SOLUTION");
        else printf("%d\n", t);
    }
    
    
    return 0;
}

176. 装满的油箱

有N个城市（编号0、1…N-1）和M条道路，构成一张无向图。

在每个城市里边都有一个加油站，不同的加油站的单位油价不一样。

现在你需要回答不超过100个问题，在每个问题中，请计算出一架油箱容量为C的车子，从起点城市S开到终点城市E至少要花多少油钱？

输入格式
第一行包含两个整数N和M。
第二行包含N个整数，代表N个城市的单位油价，第i个数即为第i个城市的油价pi。
接下来M行，每行包括三个整数u,v,d，表示城市u与城市v之间存在道路，且车子从u到v需要消耗的油量为d。
接下来一行包含一个整数q，代表问题数量。
接下来q行，每行包含三个整数C、S、E，分别表示车子油箱容量、起点城市S、终点城市E。

输出格式
对于每个问题，输出一个整数，表示所需的最少油钱。
如果无法从起点城市开到终点城市，则输出”impossible”。
每个结果占一行。

数据范围
1≤N≤1000,
1≤M≤10000,
1≤pi≤100,
1≤d≤100,
1≤C≤100

输入样例：
5 5
10 10 20 12 13
0 1 9
0 2 8
1 2 1
1 3 11
2 3 7
2
10 0 3
20 1 4

输出样例：
170
impossible

/*
每个点的属性 (编号，当前剩余油量) 编号1000 油量100
总点数 100000(编号1000 油量100)
总边数 20000(无向边，一个方向100000，两个方向20000)

(S,0)->(T,0) 最少需要花多少钱

边：
    1.(ver,c)->(ver,c + 1), if c + 1 <= C
    2.(ver,c)->(new ver,c - cost[i]) if c >= cost[i]

*/

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 1010, M = 20010, C = 1010;

int n, m;
int h[N], e[M], w[M], ne[M], idx;
int price[N];
int dist[N][C];
bool st[N][C];

struct Ver
{
    int d, u, c;
    bool operator< (const Ver &W)const //重载< 号
    {
        return d > W.d;
    }
};

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

int dijkstra(int c, int start, int end)
{
    priority_queue<Ver> heap; 
    memset(dist, 0x3f, sizeof dist);
    memset(st, false, sizeof st);
    heap.push({0, start, 0});
    
    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();
        
        if(t.u == end) return t.d; //找到最小值，返回最短路径
        
        if(st[t.u][t.c]) continue; //当前状态搜过
        st[t.u][t.c] = true;
        
        if(t.c < c)
        {
            if(dist[t.u][t.c + 1] > t.d + price[t.u])
            {
                dist[t.u][t.c + 1] = t.d + price[t.u];
                heap.push({dist[t.u][t.c + 1], t.u, t.c + 1}); //第一种情况
            }
        }
        
        for(int i = h[t.u]; ~i; i = ne[i]) //第二种情况 枚举领边
        {
            int j = e[i];
            if(t.c >= w[i])
            {
                if(dist[j][t.c - w[i]] > t.d)
                {
                    dist[j][t.c - w[i]] = t.d;
                    heap.push({t.d, j, t.c - w[i]});
                }
            }
        }
    }
    return -1;
}

int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; i ++) scanf("%d", &price[i]);
    memset(h, -1, sizeof h);
    while(m --)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c), add(b, a, c); //无向边
    }
    
    int query;
    scanf("%d", &query);
    while(query --)
    {
        int c, s, e; //起点 终点 容量
        scanf("%d%d%d", &c, &s, &e);
        int t = dijkstra(c, s, e);
        if(t == -1) puts("impossible");
        else printf("%d\n", t);
    }
    
    return 0;
}

177. 噩梦

给定一张N*M的地图，地图中有1个男孩，1个女孩和2个鬼。
字符“.”表示道路，字符“X”表示墙，字符“M”表示男孩的位置，字符“G”表示女孩的位置，字符“Z”表示鬼的位置。
男孩每秒可以移动3个单位距离，女孩每秒可以移动1个单位距离，男孩和女孩只能朝上下左右四个方向移动。
每个鬼占据的区域每秒可以向四周扩张2个单位距离，并且无视墙的阻挡，也就是在第k秒后所有与鬼的曼哈顿距离不超过2k的位置都会被鬼占领。
注意： 每一秒鬼会先扩展，扩展完毕后男孩和女孩才可以移动。
求在不进入鬼的占领区的前提下，男孩和女孩能否会合，若能会合，求出最短会合时间。

输入格式
第一行包含整数T，表示共有T组测试用例。
每组测试用例第一行包含两个整数N和M，表示地图的尺寸。
接下来N行每行M个字符，用来描绘整张地图的状况。（注意：地图中一定有且仅有1个男孩，1个女孩和2个鬼）

输出格式
每个测试用例输出一个整数S，表示最短会合时间。
如果无法会合则输出-1。
每个结果占一行。

数据范围
1<n,m<800

输入样例：

3
5 6
XXXXXX
XZ..ZX
XXXXXX
M.G...
......
5 6
XXXXXX
XZZ..X
XXXXXX
M.....
..G...
10 10
..........
..X.......
..M.X...X.
X.........
.X..X.X.X.
.........X
..XX....X.
X....G...X
...ZX.X...
...Z..X..X

输出样例：
1
1
-1

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>

using namespace std;

typedef pair<int, int>PII;

const int N = 810;

int n, m;
char g[N][N];
int st[N][N];
PII ghost[2], boy, girl;

bool check(int x, int y, int step)
{
    if(x < 0 || x >= n || y < 0 || y >= m || g[x][y] == 'X') return false;
    for(int i = 0; i < 2; i++)
        if(abs(x - ghost[i].first) + abs(y - ghost[i].second) <= step * 2) return false;
    return true;    
}

int bfs()
{
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1}; //上右下左
    
    int cnt = 0;
    memset(st, 0, sizeof st);
    for(int i = 0; i < n; i ++)
        for(int j = 0; j < m; j ++)
            if(g[i][j] == 'M') boy = {i, j};
            else if(g[i][j] == 'G') girl = {i, j};
            else if(g[i][j] == 'Z') ghost[cnt ++] = {i, j};
    
    int step = 0;        
    queue<PII> qb, qg;
    qb.push(boy), qg.push(girl);
    while(qb.size() || qg.size())
    {
        step ++;
        //男生扩展
        for(int i = 0; i < 3; i++)
            for(int j = 0, len = qb.size(); j < len; j++)
            {
                auto t = qb.front();
                qb.pop();
                int x = t.first, y = t.second;
                if(!check(x, y, step)) continue; //当前没有被鬼扩展
                for(int k = 0; k < 4; k ++) //枚举四个方向
                {
                    int a = x + dx[k], b = y + dy[k];
                    if(check(a, b, step))
                    {
                        if(st[a][b] == 2) return step; //女生位置
                        if(!st[a][b])
                        {
                            st[a][b] = 1;
                            qb.push({a, b});
                        }
                    }
                }
            }
            //女生扩展
            for(int i = 0; i < 1; i++)
            for(int j = 0, len = qg.size(); j < len; j++)
            {
                auto t = qg.front();
                qg.pop();
                int x = t.first, y = t.second;
                if(!check(x, y, step)) continue; //当前没有被鬼扩展
                for(int k = 0; k < 4; k ++) //枚举四个方向
                {
                    int a = x + dx[k], b = y + dy[k];
                    if(check(a, b, step))
                    {
                        if(st[a][b] == 1) return step; //男生位置
                        if(!st[a][b])
                        {
                            st[a][b] = 2;
                            qg.push({a, b});
                        }
                    }
                }
            }
    }
    return -1;
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T --)
    {
        scanf("%d%d", &n, &m);
        for(int i = 0; i < n; i ++) scanf("%s", g[i]);
        printf("%d\n", bfs()); //双向宽搜
    }
    
    
    return 0;
}