《算法竞赛进阶指南》2.7Astar

178. 第K短路

给定一张N个点（编号1,2…N），M条边的有向图，求从起点S到终点T的第K短路的长度，路径允许重复经过点或边。
注意： 每条最短路中至少要包含一条边。

输入格式
第一行包含两个整数N和M。
接下来M行，每行包含三个整数A,B和L，表示点A与点B之间存在有向边，且边长为L。
最后一行包含三个整数S,T和K，分别表示起点S，终点T和第K短路。

输出格式
输出占一行，包含一个整数，表示第K短路的长度，如果第K短路不存在，则输出“-1”。

数据范围
1≤S,T≤N≤1000,
0≤M≤105,
1≤K≤1000,
1≤L≤100

输入样例：
2 2
1 2 5
2 1 4
1 2 2

输出样例：
14

/*
A* star

在最短路径问题中，如果所有边权都是非负的，那么就可以使用启发函数来优化BFS过程。

启发函数：
dist + f(s)
只要f(s) <= g(s) (以及单调性)，就可以保证，当某个状态s，第一次从优先队列中出来时，它的距离就一定是最短距离了。

1.建立反图，然后在反向图上求出从终点T到其他所有点的最短距离，作为每个点的估价函数
2.从起点S开始扩展，每次取出当前的估计值最下的点，将其所有能扩展到的点全部扩展。估计值 = 距离起点的真是距离 + 估价函数
3.当第K次遇到T时，就求出了从S到T的第K短路
*/

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

using namespace std;

typedef pair<int, int> PII;
typedef pair<int, PII> PIII;

const int N = 1010, M = 200010;

int n, m;
int h[N], rh[N], e[M], w[M], ne[M], idx;
int dist[N], f[N], st[N]; //到每个点的最短距离 点的值 重复次数
int S, T, K;

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

void dijkstra()
{
    priority_queue<PII, vector<PII>, greater<PII>> heap; //小根堆
    memset(dist, 0x3f, sizeof dist);
    dist[T] = 0; //反向图求最短距离
    heap.push({0, T});
    
    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();
        
        int ver = t.second;
        if(st[ver]) continue;
        st[ver] = 1;
        
        for(int i = rh[ver]; ~i; i = ne[i]) //当前点到所有点的距离
        {
            int j = e[i];
            if(dist[j] > dist[ver] + w[i])
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});
            }
        }
    }
    memcpy(f, dist, sizeof f);
}

int a_star()
{
    priority_queue<PIII, vector<PIII>, greater<PIII>> heap;
    heap.push({f[S], {0, S}}); //按估价函数排序
    memset(st, 0, sizeof st);
    
    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();
        
        int ver = t.second.second, distance = t.second.first;
        if(st[ver] >= K) continue;
        st[ver] ++;
        if(ver == T && st[ver] == K) return distance;
        
        for(int i = h[ver]; ~i; i = ne[i])
        {
            int j = e[i];
            if(st[j] < K)
                heap.push({distance + w[i] + f[j], {distance + w[i], j}});
        }
    }
    return -1;
}

int main()
{
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    memset(rh, -1, sizeof rh);
    while(m --)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(h, a, b, c), add(rh, b, a, c);
    }
    scanf("%d%d%d", &S, &T, &K);
    if(S == T) K ++;
    
    dijkstra();
    
    printf("%d\n", a_star());
    
    return 0;
}

179. 八数码

在一个3×3的网格中，1~8这8个数字和一个“X”恰好不重不漏地分布在这3×3的网格中。

例如：

1 2 3
X 4 6
7 5 8

在游戏过程中，可以把“X”与其上、下、左、右四个方向之一的数字交换（如果存在）。
我们的目的是通过交换，使得网格变为如下排列（称为正确排列）：

1 2 3
4 5 6
7 8 X

例如，示例中图形就可以通过让“X”先后与右、下、右三个方向的数字交换成功得到正确排列。
交换过程如下：

1 2 3   1 2 3   1 2 3   1 2 3
X 4 6   4 X 6   4 5 6   4 5 6
7 5 8   7 5 8   7 X 8   7 8 X

把“X”与上下左右方向数字交换的行动记录为“u”、“d”、“l”、“r”。
现在，给你一个初始网格，请你通过最少的移动次数，得到正确排列。

输入格式
输入占一行，将3×3的初始网格描绘出来。
例如，如果初始网格如下所示：

1 2 3

x 4 6

7 5 8

则输入为：1 2 3 x 4 6 7 5 8

输出格式
输出占一行，包含一个字符串，表示得到正确排列的完整行动记录。
如果不存在解决方案，则输出”unsolvable”。

输入样例：
2 3 4 1 5 x 7 6 8

输出样例
ullddrurdllurdruldr

/*

八数码问题无解， 当且仅当 逆序对数量是奇数.

1~8每个数和最终位置的曼哈顿距离之和

string, unordered_map<string, int>

*/

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

using namespace std;

int f(string state)
{
    int res = 0;
    for(int i = 0; i < state.size(); i++)
        if(state[i] != 'x')
        {
            int t = state[i] - '1';
            res += abs(i / 3 - t / 3) + abs(i % 3 - t % 3);
        }
        return res;
}

string bfs(string start)
{
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1}; //上右下左 
    char op[4] = {'u', 'r', 'd', 'l'};
    
    string end = "12345678x";
    unordered_map<string, int> dist; //当前距离
    unordered_map<string, bool> st; //当前状态是不是被搜过
    unordered_map<string, pair<string, char>> prev;
    priority_queue<pair<int, string>, vector<pair<int, string>>, greater<pair<int, string>>> heap;
    
    heap.push({f(start), start});
    dist[start] = 0;
    
    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();
        
        string state = t.second;
        
        if(state == end) break;
        
        if(st[state]) continue;
        st[state] = true;
        
        int step = dist[state];
        int x, y; //求当前空格位置
        for(int i = 0; i < state.size(); i++)
            if(state[i] == 'x')
            {
                x = i / 3, y = i % 3;
                break;
            }
        string source = state;
        for(int i = 0; i < 4; i ++)
        {
            int a = x + dx[i], b = y + dy[i];
            if(a >= 0 && a < 3 && b >= 0 && b < 3)
            {
                swap(state[x * 3 + y], state[a * 3 + b]);
                if(!dist.count(state) || dist[state] > step + 1)
                {
                    dist[state] = step + 1;
                    prev[state] = {source, op[i]};
                    heap.push({dist[state] + f(state), state});
                }
                swap(state[x * 3 + y], state[a * 3 + b]);
            }
        }
    }
    string res;
    while(end != start)
    {
        res += prev[end].second;
        end = prev[end].first;
    }
    reverse(res.begin(), res.end());
    return res;
}

int main()
{
    string g, c, seq;
    while(cin >> c)
    {
        g += c;
        if(c != "x") seq += c;
    }
    
    int t = 0;
    for(int i = 0; i < seq.size(); i++)
        for(int j = i + 1; j < seq.size(); j ++)
            if(seq[i] > seq[j])
                t ++;
                
    if(t % 2) puts("unsolvable"); 
    else cout << bfs(g) << endl;
    
    return 0;
}