给定一个大小为 NxN 的二进制矩阵，其中 1 表示数字 i 可以转换为 j，而 0 表示它不能转换为。还给出了两个数字 X(
Input:
{{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
{ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}}
X = 2, Y = 3
Output: 2
Convert 2 -> 4 -> 3, which is the minimum way possible.
Input:
{{ 0, 0, 0, 0}
{ 0, 0, 0, 1}
{ 0, 0, 0, 0}
{ 0, 1, 0, 0}}
X = 1, Y = 2
Output: -1 方法：此问题是 Floyd-warshall 算法的变体，其中 i 和 j 之间存在权重为 1 的边，即mat[i][j]==1 ，否则它们没有边，我们可以将边分配为无穷大，就像我们在 Floyd-Warshall 中所做的那样。找到解矩阵，如果不是无穷大，则返回dp[i][j] 。如果它是无限的，则返回-1 ，这意味着它们之间没有可能的路径。
下面是上述方法的实现：
C++
// C++ implementation of the above approach
#include
using namespace std;
#define INF 99999
#define size 10
int findMinimumSteps(int mat[size][size], int x, int y, int n)
{
// dist[][] will be the output matrix that
// will finally have the shortest
// distances between every pair of numbers
int dist[n][n], i, j, k;
// Initially same as mat
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (mat[i][j] == 0)
dist[i][j] = INF;
else
dist[i][j] = 1;
if (i == j)
dist[i][j] = 1;
}
}
// Add all numbers one by one to the set
// of intermediate numbers. Before start of
// an iteration, we have shortest distances
// between all pairs of numbers such that the
// shortest distances consider only the numbers
// in set {0, 1, 2, .. k-1} as intermediate numbers.
// After the end of an iteration, vertex no. k is
// added to the set of intermediate numbers and
// the set becomes {0, 1, 2, .. k}
for (k = 0; k < n; k++) {
// Pick all numbers as source one by one
for (i = 0; i < n; i++) {
// Pick all numbers as destination for the
// above picked source
for (j = 0; j < n; j++) {
// If number k is on the shortest path from
// i to j, then update the value of dist[i][j]
if (dist[i][k] + dist[k][j] < dist[i][j])
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
// If no path
if (dist[x][y] < INF)
return dist[x][y];
else
return -1;
}
// Driver Code
int main()
{
int mat[size][size] = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 } };
int x = 2, y = 3;
cout << findMinimumSteps(mat, x, y, size);
} Java
// Java implementation of the above approach
class GFG
{
static int INF=99999;
static int findMinimumSteps(int mat[][], int x, int y, int n)
{
// dist[][] will be the output matrix that
// will finally have the shortest
// distances between every pair of numbers
int i, j, k;
int [][] dist= new int[n][n];
// Initially same as mat
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (mat[i][j] == 0)
dist[i][j] = INF;
else
dist[i][j] = 1;
if (i == j)
dist[i][j] = 1;
}
}
// Add all numbers one by one to the set
// of intermediate numbers. Before start of
// an iteration, we have shortest distances
// between all pairs of numbers such that the
// shortest distances consider only the numbers
// in set {0, 1, 2, .. k-1} as intermediate numbers.
// After the end of an iteration, vertex no. k is
// added to the set of intermediate numbers and
// the set becomes {0, 1, 2, .. k}
for (k = 0; k < n; k++) {
// Pick all numbers as source one by one
for (i = 0; i < n; i++) {
// Pick all numbers as destination for the
// above picked source
for (j = 0; j < n; j++) {
// If number k is on the shortest path from
// i to j, then update the value of dist[i][j]
if (dist[i][k] + dist[k][j] < dist[i][j])
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
// If no path
if (dist[x][y] < INF)
return dist[x][y];
else
return -1;
}
// Driver Code
public static void main(String []args)
{
int [][] mat = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 } };
int x = 2, y = 3;
int size=mat.length;
System.out.println( findMinimumSteps(mat, x, y, size));
}
}
// This code is contributed by ihritikPython3
# Pyton3 implementation of the above approach
INF = 99999
size = 10
def findMinimumSteps(mat, x, y, n):
# dist[][] will be the output matrix
# that will finally have the shortest
# distances between every pair of numbers
dist = [[0 for i in range(n)]
for i in range(n)]
i, j, k = 0, 0, 0
# Initially same as mat
for i in range(n):
for j in range(n):
if (mat[i][j] == 0):
dist[i][j] = INF
else:
dist[i][j] = 1
if (i == j):
dist[i][j] = 1
# Add all numbers one by one to the set
# of intermediate numbers. Before start
# of an iteration, we have shortest distances
# between all pairs of numbers such that the
# shortest distances consider only the numbers
# in set {0, 1, 2, .. k-1} as intermediate
# numbers. After the end of an iteration, vertex
# no. k is added to the set of intermediate
# numbers and the set becomes {0, 1, 2, .. k}
for k in range(n):
# Pick all numbers as source one by one
for i in range(n):
# Pick all numbers as destination
# for the above picked source
for j in range(n):
# If number k is on the shortest path from
# i to j, then update the value of dist[i][j]
if (dist[i][k] + dist[k][j] < dist[i][j]):
dist[i][j] = dist[i][k] + dist[k][j]
# If no path
if (dist[x][y] < INF):
return dist[x][y]
else:
return -1
# Driver Code
mat = [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],
[ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ]]
x, y = 2, 3
print(findMinimumSteps(mat, x, y, size))
# This code is contributed by Mohit kumar 29C#
// C# implementation of the above approach
using System;
class GFG
{
static int INF=99999;
static int findMinimumSteps(int [,]mat, int x, int y, int n)
{
// dist[][] will be the output matrix that
// will finally have the shortest
// distances between every pair of numbers
int i, j, k;
int [,] dist= new int[n,n];
// Initially same as mat
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (mat[i,j] == 0)
dist[i,j] = INF;
else
dist[i,j] = 1;
if (i == j)
dist[i,j] = 1;
}
}
// Add all numbers one by one to the set
// of intermediate numbers. Before start of
// an iteration, we have shortest distances
// between all pairs of numbers such that the
// shortest distances consider only the numbers
// in set {0, 1, 2, .. k-1} as intermediate numbers.
// After the end of an iteration, vertex no. k is
// added to the set of intermediate numbers and
// the set becomes {0, 1, 2, .. k}
for (k = 0; k < n; k++) {
// Pick all numbers as source one by one
for (i = 0; i < n; i++) {
// Pick all numbers as destination for the
// above picked source
for (j = 0; j < n; j++) {
// If number k is on the shortest path from
// i to j, then update the value of dist[i][j]
if (dist[i,k] + dist[k,j] < dist[i,j])
dist[i,j] = dist[i,k] + dist[k,j];
}
}
}
// If no path
if (dist[x,y] < INF)
return dist[x,y];
else
return -1;
}
// Driver Code
public static void Main()
{
int [,] mat = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 } };
int x = 2, y = 3;
int size = mat.GetLength(0) ;
Console.WriteLine( findMinimumSteps(mat, x, y, size));
}
// This code is contributed by Ryuga
}Javascript
输出：
2如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。