leetcode之最短路径+记忆化dfs+bfs+动态规划刷题总结
最短路:给定两个顶点，在以这两个顶点为起点和终点的路径中，边的权值和最小的路径。
最短路径中有几种经典的算法，我们主要练习的是Dijkstra算法和Floyd算法，分别用于解决单元最短路径问题和多源最短路径问题。
Dijkstra算法适用于单源最短路径，具体地，找到最短路已经确定的节点，从它出发更新相邻节点的最短距离。
Floyd算法适用于多源最短路径，具体地，通过一系列n阶矩阵来计算一个n节点加权图的最短距离。每轮让第k个节点做中转节点，更新第i个节点到第j个节点的最短路径。
动态规划常常适用于有重叠子问题和最优子结构性质的问题，并且记录所有子问题的结果，因此动态规划方法所耗时间往往远少于朴素解法。
动态规划有自底向上和自顶向下两种解决问题的方式。自顶向下即记忆化递归，自底向上就是递推。
记忆化即记忆化搜索，也叫记忆化递归，其实就是拆分子问题的时候，发现有很多重复子问题，然后再求解它们以后记录下来。以后再遇到要求解同样规模的子问题的时候，直接读取答案。
使用动态规划解决的问题有个明显的特点，一旦一个子问题的求解得到结果，以后的计算过程就不会修改它，这样的特点叫做无后效性，求解问题的过程形成了一张有向无环图。动态规划只解决每个子问题一次，具有天然剪枝的功能，从而减少计算量。
深度优先搜索算法（英语：Depth-First-Search，DFS）是一种用于遍历或搜索树或图的算法。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次.
广度优先搜索算法（Breadth-First Search，缩写为 BFS），又称为宽度优先搜索，是一种图形搜索算法。简单的说，BFS 是从根结点开始，沿着树的宽度遍历树的结点。如果所有结点均被访问，则算法中止。
1-电动车游城市
题目链接：题目链接戳这里！！！
思路：Dijkstra算法
对paths数组建立邻接表，分别存储两个相邻节点以及节点之间的权值，ans数组记录到达当前节点的最少用时，优先队列中存储所用时间，当前位置，剩余电量，并且按照所用时间升序排序，保证每次选择的都是所用时间最少的，如果电量未满可以考虑充电，如如果剩余电量够，可以往相邻的节点走。
class Solution {
public int electricCarPlan(int[][] paths, int cnt, int start, int end, int[] charge) {
int n = charge.length ;
List<int[]> [] g = new List[n] ;
for(int i=0; i<n; i++){
g[i] = new ArrayList<int[]>() ;
}
for(int [] path : paths){ //建立邻接表，后面好操作
int u = path[0], v = path[1], w = path[2] ;
g[u].add(new int [] {v, w}) ;
g[v].add(new int [] {u, w}) ;
}
int [][] ans = new int [n][cnt+1] ; //当前位置n，剩余电量cnt，时候的最少用时
for(int i=0; i<n; i++){
Arrays.fill(ans[i], Integer.MAX_VALUE/2) ;
}
ans[start][0] = 0 ;
PriorityQueue<int []> queue = new PriorityQueue<>((a,b)->(a[0]-b[0])) ;
queue.add(new int [] {0, start, 0}) ; //数组中三个元素分别为已用时间，当前位置，剩余电量
while(!queue.isEmpty()){
int [] p = queue.poll() ;
int time = p[0], cur = p[1], power = p[2] ;
if(time > ans[cur][power]){
continue ;
}
if(cur == end){
return time ;
}
if(power<cnt){//电量未满，可以考虑充电
int t = time + charge[cur] ;
if(t<ans[cur][power+1]){
ans[cur][power+1] = t ;
queue.add(new int [] {t, cur, power+1}) ;
}
}
for(int [] path : g[cur]){
int next = path[0] ;
int cost = path[1] ;
int t = time + cost ;
int pow = power - cost ;
if(pow>=0 && t<ans[next][pow]){
ans[next][pow] = t ;
queue.add(new int [] {t, next, pow}) ;
}
}
}
return -1 ;
}
}
2-K站中转内最便宜的航班
题目链接：题目链接戳这里！！！
思路1：记忆化搜索(dfs)
从src出发，搜索所有能到dst的，并且中转个数少于k的路径，找出价格最便宜的路径价格。
用memo[i][k]做记忆化，防止重复计算，该数组表示从i点到达终点经历不超过k次中转的最低价格。
class Solution {
int INF = 1000000007 ;
public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
//记忆化搜索
//memo[i][k]数组记录从当前顶点i出发经过最多k个中转点到最后的顶点的最便宜的价格
int [][] memo = new int [n][k+2] ;
int ans = dfs(flights, src, dst, k+1, memo) ;
return ans>=INF ? -1 : ans ;
}
public int dfs(int [][] flights, int i, int end, int k, int [][] memo){
if(k<0){
return INF ;
}
if(i==end){
return 0 ;
}
if(memo[i][k] != 0){
return memo[i][k] ;
}
int min = INF ;
for(int [] flight : flights){
if(flight[0]==i){
min = Math.min(min, dfs(flights, flight[1], end, k-1, memo) + flight[2]) ;
}
}
memo[i][k] = min ;
return min ;
}
}
思路2：bfs+剪支
对于当前节点，遍历相邻节点，每一轮bfs，k减少1，如果找到更小的价格，则更新ans数组。
class Solution {
int INF = 1000000007 ;
public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
//bfs+剪支
List<int []> [] g = new List[n] ;
for(int i=0; i<n; i++){
g[i] = new ArrayList<>() ;
}
for(int [] flight : flights){
int u = flight[0], v = flight[1], w=flight[2] ;
g[u].add(new int [] {v, w}) ;
}
int [] ans = new int [n] ;
Arrays.fill(ans, Integer.MAX_VALUE) ;
Queue<int []> queue = new LinkedList<>() ;
queue.add(new int [] {src, 0}) ;
while(!queue.isEmpty() && k+1>0){
int size = queue.size() ;
for(int i=0; i<size; i++){
int [] p = queue.poll() ;
for(int [] f : g[p[0]]){
int price = p[1] + f[1];
if(price < ans[f[0]]){
ans[f[0]] = price ;
if(f[0] != dst){
queue.add(new int [] {f[0], price}) ;
}
}
}
}
k -- ;
}
return ans[dst] >= INF ? -1 : ans[dst] ;
}
}
思路3：动态规划
其实就是记忆化递归的转换，自顶向下变成自底向上。
class Solution {
int INF = 1000000007 ;
public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
//动态规划
//dp[i][k]表示从i点出发到dst走最多k+1步的最少价格
int [][] dp = new int [n][k+2] ;
for(int i=0; i<n; i++)
Arrays.fill(dp[i],INF) ;
return f(n, flights, src, dst, k+1, dp) ;
}
public int f(int n, int [][] flights, int src, int dst, int K, int [][] dp){
dp[dst][0] = 0 ;
for(int k=1; k<=K; k++){
for(int [] flight : flights){
dp[flight[0]][k] = Math.min(dp[flight[0]][k], dp[flight[1]][k-1] + flight[2]) ;
}
}
int ans = IntStream.of(dp[src]).min().getAsInt() ;
return ans >= INF ? -1 : ans ;
}
}
3-阈值距离内邻居最少的城市
题目链接：题目据链接戳这里！！！
思路：首先要求出来每个节点到其余节点的最短路径，所以可以使用Floyd算法，使用matrix矩阵记录从i节点到j节点的最短路长度，然后遍历所有i节点，如果到达j节点的距离小于等于distanceThreshold，则使用nums[i]记录满足要求的路径数量，选择最小值。
class Solution {
public int findTheCity(int n, int[][] edges, int distanceThreshold) {
//多源最短路径，使用Floyd算法
int [][] matrix = new int [n][n] ;
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
matrix[i][j] = 1000000000 ;
}
}
for(int i=0; i<n; i++){
matrix[i][i] = 0 ;
}
for(int [] edge : edges){
int u = edge[0], v = edge[1], w = edge[2] ;
matrix[u][v] = matrix[v][u] = w ;
}
for(int k=0; k<n; k++){
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
matrix[i][j] = Math.min(matrix[i][j], matrix[i][k]+matrix[k][j]) ;
}
}
}
int [] num = new int [n] ;
int pos = -1, min = 1000000000 ;
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
if(matrix[i][j]<=distanceThreshold){
num[i] ++ ;
}
}
if(num[i] <= min){
min = num[i] ;
pos = i ;
}
}
return pos ;
}
}
**
不辜负每一份热情，不讨好每一份冷漠，做好自己，健健康康为祖国工作50年！！！
**
1024
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
