📜  腐烂所有橘子所需的最短时间|动态编程

📅  最后修改于: 2021-05-07 05:51:11             🧑  作者: Mango

鉴于m维的矩阵* n,其中矩阵中的每个单元可具有具有以下含义的值0,12:

0: Empty cell

1: Cells have fresh oranges

2: Cells have rotten oranges

因此,任务是确定使所有橙子变烂所需的最短时间是多少。索引为[i,j]的烂橙可以使索引为[i – 1,j][i + 1,j][i,j – 1][i,j + 1]的其他新鲜橙子腐烂(向上,向下,向左和向右)。如果不可能腐烂每个橙色,则只需返回-1即可
例子:

方法:这里讨论了基于BFS的方法。

在这篇文章中,我们使用动态编程解决了这个问题。

每个橘子都需要烂掉。任何橙色都可以被最近的橙色烂掉。因此,对于尚未腐烂的每个橙子,我们找到其与腐烂的橙子的最小距离,然后取最大的最大值,这表示腐烂所有橙子所需的最短时间。

令dp(i,j)=该橙与任何烂橙的最小距离,因此,DP状态为:

对于所有i,j,我们的答案将是max(dp(i,j)),其中arr [i] [j] == 1。

下面是上述方法的实现:

C++
// C++ implementation of the approach
 
#include 
using namespace std;
#define C 5
#define R 3
#define INT_MAX 10000000
 
// DP table to memoize the values
int table[R][C] = { 0 };
 
// Visited array to keep
// track of visited nodes
// in order to avoid infinite loops
int visited[R][C] = { 0 };
 
// Function to return the
// minimum of four numbers
int min(int p, int q, int r, int s)
{
    int temp1 = p < q ? p : q;
    int temp2 = r < s ? r : s;
 
    if (temp1 < temp2)
        return temp1;
    return temp2;
}
 
// Function to return the minimum distance
// to any rotten orange from [i, j]
int Distance(int arr[R][C], int i, int j)
{
    // If i, j  lie outside the array
    if (i >= R || j >= C || i < 0 || j < 0)
        return INT_MAX;
 
    // If 0 then it can't lead to
    // any path so return INT_MAX
    else if (arr[i][j] == 0) {
        table[i][j] = INT_MAX;
        return INT_MAX;
    }
 
    // If 2 then we have reached
    // our rotten oranges
    // so return from here
    else if (arr[i][j] == 2) {
        table[i][j] = 0;
        return 0;
    }
 
    // If this node is already visited
    // then return to avoid infinite loops
    else if (visited[i][j]) {
        return INT_MAX;
    }
    else {
 
        // Mark the current node as visited
        visited[i][j] = 1;
 
        // Check in all four possible directions
        int temp1 = Distance(arr, i + 1, j);
        int temp2 = Distance(arr, i - 1, j);
        int temp3 = Distance(arr, i, j + 1);
        int temp4 = Distance(arr, i, j - 1);
 
        // Take the minimum of all
        int min_value = 1 + min(temp1,
                    temp2, temp3, temp4);
 
        // If result already exists in the table
        // check if min_value is less
        // than existing value
        if (table[i][j] > 0 &&
            table[i][j] < INT_MAX) {
            if (min_value < table[i][j])
                table[i][j] = min_value;
        }
        else
            table[i][j] = min_value;
        visited[i][j] = 0;
        return table[i][j];
    }
}
 
// Function to return the minimum time
// required to rot all the oranges
int minTime(int arr[][C])
{
    int max = 0;
 
    // Calculate the minimum
    // distances to any rotten
    // orange from all the fresh oranges
    for (int i = 0; i < R; i++) {
        for (int j = 0; j < C; j++) {
            if (arr[i][j] == 1)
                Distance(arr, i, j);
        }
    }
 
    // Pick the maximum distance of fresh orange
    // to some rotten orange
    for (int i = 0; i < R; i++) {
        for (int j = 0; j < C; j++) {
            if (arr[i][j] == 1 &&
                table[i][j] > max)
                max = table[i][j];
        }
    }
 
    // If all oranges can be rotten
    if (max < INT_MAX)
        return max;
 
    return -1;
}
 
// Driver Code
int main()
{
 
    int arr[R][C] = { { 2, 1, 0, 2, 1 },
                      { 0, 0, 1, 2, 1 },
                      { 1, 0, 0, 2, 1 } };
 
    cout << minTime(arr);
    return 0;
}


Java
// Java implementation of the approach
 
class GFG {
    static int C = 5;
    static int R = 3;
    static int INT_MAX = 10000000;
 
    // DP table to memoize the values
    static int[][] table = new int[R][C];
 
    // Visited array to keep
    // track of visited nodes
    // in order to avoid infinite loops
    static int[][] visited = new int[R][C];
 
    // Function to return the
    // minimum of four numbers
    static int min(int p, int q, int r, int s)
    {
        int temp1 = p < q ? p : q;
        int temp2 = r < s ? r : s;
 
        if (temp1 < temp2)
            return temp1;
        return temp2;
    }
 
    // Function to return the
    // minimum distance
    // to any rotten orange from [i, j]
    static int Distance(int arr[][], int i, int j)
    {
        // If i, j lie outside the array
        if (i >= R || j >= C || i < 0 || j < 0)
            return INT_MAX;
 
        // If 0 then it can't lead to
        // any path so return INT_MAX
        else if (arr[i][j] == 0) {
            table[i][j] = INT_MAX;
            return INT_MAX;
        }
 
        // If 2 then we have reached
        // our rotten oranges
        // so return from here
        else if (arr[i][j] == 2) {
            table[i][j] = 0;
            return 0;
        }
 
        // If this node is already visited
        // then return to avoid
        // infinite loops
        else if (visited[i][j] == 1) {
            return INT_MAX;
        }
        else {
 
            // Mark the current node
            // as visited
            visited[i][j] = 1;
 
            // Check in all four
            // possible directions
            int temp1 = Distance(arr, i + 1, j);
            int temp2 = Distance(arr, i - 1, j);
            int temp3 = Distance(arr, i, j + 1);
            int temp4 = Distance(arr, i, j - 1);
 
            // Take the minimum of all
            int min_value
                = 1 + min(temp1, temp2, temp3, temp4);
            // If result already exists in
            // the table check if min_value
            // is less than existing value
            if (table[i][j] > 0 &&
                table[i][j] < INT_MAX) {
                if (min_value < table[i][j])
                    table[i][j] = min_value;
            }
            else
                table[i][j] = min_value;
 
            visited[i][j] = 0;
        }
        return table[i][j];
    }
 
    // Function to return the minimum time
    // required to rot all the oranges
    static int minTime(int arr[][])
    {
        int max = 0;
 
        // Calculate the minimum
        // distances to any rotten
        // orange from all the fresh oranges
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                if (arr[i][j] == 1)
                    Distance(arr, i, j);
            }
        }
 
        // Pick the maximum distance
        // of fresh orange
        // to some rotten orange
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                if (arr[i][j] == 1 &&
                    table[i][j] > max)
                    max = table[i][j];
            }
        }
 
        // If all oranges can be rotten
        if (max < INT_MAX)
            return max;
 
        return -1;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int arr[][] = { { 2, 1, 0, 2, 1 },
                        { 0, 0, 1, 2, 1 },
                        { 1, 0, 0, 2, 1 } };
 
        System.out.println(minTime(arr));
    }
}
 
// This code is contributed by Rajput-Ji


Python3
# Python 3 implementation of the approach
 
C = 5
R = 3
INT_MAX = 10000000
 
# DP table to memoize the values
table = [[0 for i in range(C)]
         for j in range(R)]
 
# Visited array to keep track
# of visited nodes
# in order to avoid infinite loops
visited = [[0 for i in range(C)]
           for j in range(R)]
 
# Function to return the
# minimum of four numbers
 
 
def min(p, q, r, s):
    if(p < q):
        temp1 = p
    else:
        temp1 = q
    if(r < s):
        temp2 = r
    else:
        temp2 = s
 
    if (temp1 < temp2):
        return temp1
    return temp2
 
# Function to return the
# minimum distance
# to any rotten orange from [i, j]
 
 
def Distance(arr, i, j):
 
    # If i, j lie outside the array
    if (i >= R or j >= C or
            i < 0 or j < 0):
        return INT_MAX
 
    # If 0 then it can't lead to
    # any path so return INT_MAX
    elif (arr[i][j] == 0):
        table[i][j] = INT_MAX
        return INT_MAX
 
    # If 2 then we have reached
    # our rotten oranges
    # so return from here
    elif (arr[i][j] == 2):
        table[i][j] = 0
        return 0
 
    # If this node is already visited
    # then return to avoid infinite loops
    elif (visited[i][j]):
        return INT_MAX
    else:
        # Mark the current node as visited
        visited[i][j] = 1
 
        # Check in all four
        # possible directions
        temp1 = Distance(arr, i + 1, j)
        temp2 = Distance(arr, i - 1, j)
        temp3 = Distance(arr, i, j + 1)
        temp4 = Distance(arr, i, j - 1)
 
        # Take the minimum of all
        min_value = 1 + min(temp1, temp2,
                            temp3, temp4)
 
        if table[i][j] > 0 and \
                table[i][j] < INT_MAX:
            if min_value < table[i][j]:
                table[i][j] = min_value
        else:
            table[i][j] = min_value
 
        visited[i][j] = 0
    return table[i][j]
 
# Function to return the minimum time
# required to rot all the oranges
 
 
def minTime(arr):
    max = 0
 
    # Calculate the minimum distances
    # to any rotten
    # orange from all the fresh oranges
    for i in range(R):
        for j in range(C):
            if (arr[i][j] == 1):
                Distance(arr, i, j)
 
    # Pick the maximum distance
    # of fresh orange
    # to some rotten orange
    for i in range(R):
        for j in range(C):
            if (arr[i][j] == 1 and
                    table[i][j] > max):
                max = table[i][j]
 
    # If all oranges can be rotten
    if (max < INT_MAX):
        return max
    return -1
 
 
# Driver Code
if __name__ == '__main__':
    arr = [[2, 1, 0, 2, 1],
           [0, 0, 1, 2, 1],
           [1, 0, 0, 2, 1]]
 
    print(minTime(arr))


C#
// C# implementation of
// the above approach
using System;
class GFG{
   
static int C = 5;
static int R = 3;
static int INT_MAX =
           10000000;
 
// DP table to memoize
// the values
static int[,] table =
       new int[R, C];
 
// Visited array to keep
// track of visited nodes
// in order to avoid infinite
// loops
static int[,] visited =
       new int[R, C];
 
// Function to return the
// minimum of four numbers
static int min(int p, int q,
               int r, int s)
{
  int temp1 = p < q ? p : q;
  int temp2 = r < s ? r : s;
 
  if (temp1 < temp2)
    return temp1;
  return temp2;
}
 
// Function to return the
// minimum distance
// to any rotten orange
// from [i, j]
static int Distance(int [,]arr,
                    int i, int j)
{
  // If i, j lie outside
  // the array
  if (i >= R || j >= C ||
      i < 0 || j < 0)
    return INT_MAX;
 
  // If 0 then it can't lead
  // to any path so return
  // INT_MAX
  else if (arr[i, j] == 0)
  {
    table[i, j] = INT_MAX;
    return INT_MAX;
  }
 
  // If 2 then we have reached
  // our rotten oranges
  // so return from here
  else if (arr[i, j] == 2)
  {
    table[i, j] = 0;
    return 0;
  }
 
  // If this node is already
  // visited then return to
  // avoid infinite loops
  else if (visited[i, j] == 1)
  {
    return INT_MAX;
  }
  else
  {
    // Mark the current node
    // as visited
    visited[i, j] = 1;
 
    // Check in all four
    // possible directions
    int temp1 = Distance(arr,
                         i + 1, j);
    int temp2 = Distance(arr,
                         i - 1, j);
    int temp3 = Distance(arr,
                         i, j + 1);
    int temp4 = Distance(arr,
                         i, j - 1);
 
    // Take the minimum of all
    int min_value = 1 + min(temp1, temp2,
                            temp3, temp4);
    // If result already exists in
    // the table check if min_value
    // is less than existing value
    if (table[i, j] > 0 &&
        table[i, j] < INT_MAX)
    {
      if (min_value < table[i, j])
        table[i, j] = min_value;
    }
    else
      table[i, j] = min_value;
 
    visited[i, j] = 0;
  }
  return table[i, j];
}
 
// Function to return the minimum
// time required to rot all the
// oranges
static int minTime(int [,]arr)
{
  int max = 0;
 
  // Calculate the minimum
  // distances to any rotten
  // orange from all the fresh
  // oranges
  for (int i = 0; i < R; i++)
  {
    for (int j = 0; j < C; j++)
    {
      if (arr[i, j] == 1)
        Distance(arr, i, j);
    }
  }
 
  // Pick the maximum distance
  // of fresh orange
  // to some rotten orange
  for (int i = 0; i < R; i++)
  {
    for (int j = 0; j < C; j++)
    {
      if (arr[i, j] == 1 &&
          table[i, j] > max)
        max = table[i, j];
    }
  }
 
  // If all oranges can be
  // rotten
  if (max < INT_MAX)
    return max;
 
  return -1;
}
 
// Driver Code
public static void Main(string[] args)
{
  int [,]arr = {{2, 1, 0, 2, 1},
                {0, 0, 1, 2, 1},
                {1, 0, 0, 2, 1}};
  Console.Write(minTime(arr));
}
}
 
// This code is contributed by Chitranayal


输出
-1