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;
}