圣殿供品

考虑一个奉献者，希望为山上的庙宇奉献物。寺庙位于不同高度的行中。每座庙宇应至少收到一份供物。如果两个相邻的庙宇处于不同的高度，那么较高的庙宇将比下方的庙宇接受更多的奉献。如果两个相邻的镜腿处于相同的高度，那么它们相对于彼此的奉献就无关紧要。给定庙宇的数量和庙宇的高度，找到要带的最小奉献物。

例子：

Input  : 3
         1 2 2
Output : 4
All temples must receive at-least one offering.
Now, the second temple is at a higher altitude
compared to the first one. Thus it receives one
extra offering. 
The second temple and third temple are at the 
same height, so we do not need to modify the 
offerings. Offerings given are therefore: 1, 2,
1 giving a total of 4.

Input  : 6
         1 4 3 6 2 1
Output : 10
We can distribute the offerings in the following
way, 1, 2, 1, 3, 2, 1. The second temple has to 
receive more offerings than the first due to its 
height being higher. The fourth must receive more
than the fifth, which in turn must receive more 
than the sixth. Thus the total becomes 10.

我们注意到，每个神庙可以在其旁边的神庙的上方，下方或同一高度。如图中所示，每个庙宇所需的供品等于较低高度的庙宇链的最大长度。

天真的方法
为了遵循给定的规则，必须提供至少一个x + 1的太阳穴，其中x是后面两个的最大值。

1. 左边的庙宇数量以升序排列。
2. 右边的庙宇数量按升序排列。

解决这个问题的一种幼稚方法是针对每个寺庙，向左走直到高度增加，然后对右侧做同样的事情。

C++

// Program to find minimum total offerings required
#include 
using namespace std;
 
// Returns minimum offerings required
int offeringNumber(int n, int templeHeight[])
{
    int sum = 0;  // Initialize result
 
    // Go through all templs one by one
    for (int i = 0; i < n; ++i)
    {
        // Go to left while height keeps increasing
        int left = 0, right = 0;
        for (int j = i - 1; j >= 0; --j)
        {
            if (templeHeight[j] < templeHeight[j + 1])
                ++left;
            else
                break;
        }
 
        // Go to right while height keeps increasing
        for (int j = i + 1; j < n; ++j)
        {
            if (templeHeight[j] < templeHeight[j - 1])
                ++right;
            else
                break;
        }
 
        // This temple should offer maximum of two
        // values to follow the rule.
        sum += max(right, left) + 1;
    }
 
    return sum;
}
 
// Driver code
int main()
{
    int arr1[3] = {1, 2, 2};
    cout << offeringNumber(3, arr1) << "\n";
    int arr2[6] = {1, 4, 3, 6, 2, 1};
    cout << offeringNumber(6, arr2) << "\n";
    return 0;
}

Java

// Program to find minimum
// total offerings required
import java.io.*;
 
class GFG
{
     
// Returns minimum
// offerings required
static int offeringNumber(int n,
                          int templeHeight[])
{
    int sum = 0; // Initialize result
 
    // Go through all
    // temples one by one
    for (int i = 0; i < n; ++i)
    {
        // Go to left while
        // height keeps increasing
        int left = 0, right = 0;
        for (int j = i - 1; j >= 0; --j)
        {
            if (templeHeight[j] <
                templeHeight[j + 1])
                ++left;
            else
                break;
        }
 
        // Go to right while
        // height keeps increasing
        for (int j = i + 1; j < n; ++j)
        {
            if (templeHeight[j] <
                templeHeight[j - 1])
                ++right;
            else
                break;
        }
 
        // This temple should offer
        // maximum of two values
        // to follow the rule.
        sum += Math.max(right, left) + 1;
    }
 
    return sum;
}
 
// Driver code
public static void main (String[] args)
{
int arr1[] = {1, 2, 2};
System.out.println(offeringNumber(3, arr1));
int arr2[] = {1, 4, 3,
              6, 2, 1};
System.out.println(offeringNumber(6, arr2));
}
}
 
// This code is contributed by akt_mit

Python3

# Program to find minimum total
# offerings required.
 
# Returns minimum offerings required
def offeringNumber(n, templeHeight):
    sum = 0 # Initialize result
     
    # Go through all templs one by one
    for i in range(n):
         
        # Go to left while height
        # keeps increasing
        left = 0
        right = 0
        for j in range(i - 1, -1, -1):
            if (templeHeight[j] < templeHeight[j + 1]):
                left += 1
            else:
                break
                 
        # Go to right while height
        # keeps increasing
        for j in range(i + 1, n):
            if (templeHeight[j] < templeHeight[j - 1]):
                right += 1
            else:
                break
                 
        # This temple should offer maximum
        # of two values to follow the rule.
        sum += max(right, left) + 1
    return sum
 
# Driver Code
arr1 = [1, 2, 2]
print(offeringNumber(3, arr1))
arr2 = [1, 4, 3, 6, 2, 1]
print(offeringNumber(6, arr2))
 
# This code is contributed
# by sahilshelangia

C#

// Program to find minimum
// total offerings required
using System;
 
class GFG
{
     
// Returns minimum
// offerings required
static int offeringNumber(int n,
                          int []templeHeight)
{
    int sum = 0; // Initialize result
 
    // Go through all
    // temples one by one
    for (int i = 0; i < n; ++i)
    {
        // Go to left while
        // height keeps increasing
        int left = 0, right = 0;
        for (int j = i - 1; j >= 0; --j)
        {
            if (templeHeight[j] <
                templeHeight[j + 1])
                ++left;
            else
                break;
        }
 
        // Go to right while
        // height keeps increasing
        for (int j = i + 1; j < n; ++j)
        {
            if (templeHeight[j] <
                templeHeight[j - 1])
                ++right;
            else
                break;
        }
 
        // This temple should offer
        // maximum of two values
        // to follow the rule.
        sum += Math.Max(right, left) + 1;
    }
 
    return sum;
}
 
// Driver code
static public void Main ()
{
    int []arr1 = {1, 2, 2};
    Console.WriteLine(offeringNumber(3, arr1));
     
    int []arr2 = {1, 4, 3,
                  6, 2, 1};
    Console.WriteLine(offeringNumber(6, arr2));
}
}
 
// This code is contributed by aj_36

PHP

= 0; --$j)
        {
            if ($templeHeight[$j] < $templeHeight[$j + 1])
                ++$left;
            else
                break;
        }
 
        // Go to right while height keeps increasing
        for ($j = $i + 1; $j < $n; ++$j)
        {
            if ($templeHeight[$j] < $templeHeight[$j - 1])
                ++$right;
            else
                break;
        }
 
        // This temple should offer maximum of two
        // values to follow the rule.
        $sum += max($right, $left) + 1;
    }
 
    return $sum;
}
 
// Driver code
    $arr1 = array (1, 2, 2);
    echo offeringNumber(3, $arr1) , "\n";
    $arr2 = array (1, 4, 3, 6, 2, 1);
    echo offeringNumber(6, $arr2) ,"\n";
     
// This code is contributed by ajit
?>

输出：

4
10

时间复杂度： O(n ² )
空间复杂度： O(1)

动态规划方法
通过使用动态编程，我们可以改善时间复杂度。在这种方法中，我们创建了一个长度为n的结构，该结构保持了每个镜腿左侧的最大递减链和每个镜腿右侧的最大递减链。我们从0到N进行一次设置每个寺庙的剩余价值。然后，我们从N到0设置每个寺庙的right值。然后，我们将两者进行比较，并为每个寺庙选择最大值。

C++

// C++ Program to find total offerings required
#include 
using namespace std;
 
// To store count of increasing order temples
// on left and right (including current temple)
struct Temple
{
    int L;
    int R;
};
 
// Returns count of minimum offerings for
// n temples of given heights.
int offeringNumber(int n, int templeHeight[])
{
    // Initialize counts for all temples
    Temple chainSize[n];
    for (int i = 0; i < n; ++i)
    {
        chainSize[i].L = -1;
        chainSize[i].R = -1;
    }
 
    // Values corner temples
    chainSize[0].L = 1;
    chainSize[n-1].R = 1;
 
    // Filling left and right values using same
    // values of previous(or next)
    for (int i=1; i=0; --i)
    {
        if (templeHeight[i + 1] < templeHeight[i])
            chainSize[i].R = chainSize[i + 1].R + 1;
        else
            chainSize[i].R = 1;
    }
 
    // Computing max of left and right for all
    // temples and returing sum.
    int sum = 0;
    for (int i = 0; i < n; ++i)
        sum += max(chainSize[i].L, chainSize[i].R);
    return sum;
}
 
// Driver function
int main()
{
    int arr1[3] = {1, 2, 2};
    cout << offeringNumber(3, arr1) << "\n";
    int arr2[6] = {1, 4, 3, 6, 2, 1};
    cout << offeringNumber(6, arr2) << "\n";
    return 0;
}

Java

// Java program to find total offerings required
import java.util.*;
  
class GFG{
      
// To store count of increasing order temples
// on left and right (including current temple)
public static class Temple
{
    public int L;
    public int R;
};
  
// Returns count of minimum offerings for
// n temples of given heights.
static int offeringNumber(int n,
                          int []templeHeight)
{
     
    // Initialize counts for all temples
    Temple []chainSize = new Temple[n];
      
    for(int i = 0; i < n; ++i)
    {
        chainSize[i] = new Temple();
        chainSize[i].L = -1;
        chainSize[i].R = -1;
    }
   
    // Values corner temples
    chainSize[0].L = 1;
    chainSize[n - 1].R = 1;
   
    // Filling left and right values
    // using same values of
    // previous(or next)
    for(int i = 1; i < n; ++i)
    {
        if (templeHeight[i - 1] < templeHeight[i])
            chainSize[i].L = chainSize[i - 1].L + 1;
        else
            chainSize[i].L = 1;
    }
     
    for(int i = n - 2; i >= 0; --i)
    {
        if (templeHeight[i + 1] < templeHeight[i])
            chainSize[i].R = chainSize[i + 1].R + 1;
        else
            chainSize[i].R = 1;
    }
   
    // Computing max of left and right for all
    // temples and returing sum.
    int sum = 0;
    for(int i = 0; i < n; ++i)
        sum += Math.max(chainSize[i].L,
                        chainSize[i].R);
                          
    return sum;
}
  
// Driver code
public static void main(String []s)
{
    int []arr1 = { 1, 2, 2 };
    System.out.println(offeringNumber(3, arr1));
  
    int []arr2 = { 1, 4, 3, 6, 2, 1 };
    System.out.println(offeringNumber(6, arr2));
}
}
 
// This code is contributed by pratham76

Python3

# Python3 program to find temple
# offerings required
from typing import List
 
# To store count of increasing order temples
# on left and right (including current temple)
class Temple:
    def __init__(self, l: int, r: int):
         
        self.L = l
        self.R = r
 
# Returns count of minimum offerings for
# n temples of given heights.
def offeringNumber(n: int,
   templeHeight: List[int]) -> int:
     
    # Initialize counts for all temples
    chainSize = [0] * n
     
    for i in range(n):
        chainSize[i] = Temple(-1, -1)
     
    # Values corner temples
    chainSize[0].L = 1
    chainSize[-1].R = 1
     
    # Filling left and right values
    # using same values of previous(or next
    for i in range(1, n):
        if templeHeight[i - 1] < templeHeight[i]:
            chainSize[i].L = chainSize[i - 1].L + 1
        else:
            chainSize[i].L = 1
             
    for i in range(n - 2, -1, -1):
        if templeHeight[i + 1] < templeHeight[i]:
            chainSize[i].R = chainSize[i + 1].R + 1
        else:
            chainSize[i].R = 1
 
    # Computing max of left and right for all
    # temples and returing sum
    sm = 0
    for i in range(n):
        sm += max(chainSize[i].L,
                  chainSize[i].R)
         
    return sm
 
# Driver code
if __name__ == '__main__':
     
    arr1 = [ 1, 2, 2 ]
    print(offeringNumber(3, arr1))
     
    arr2 = [ 1, 4, 3, 6, 2, 1 ]
    print(offeringNumber(6, arr2))
 
# This code is contributed by Rajat Srivastava

C＃

// C# program to find total offerings required
using System;
 
class GFG{
     
// To store count of increasing order temples
// on left and right (including current temple)
public class Temple
{
    public int L;
    public int R;
};
 
// Returns count of minimum offerings for
// n temples of given heights.
static int offeringNumber(int n,
                          int []templeHeight)
{
     
    // Initialize counts for all temples
    Temple []chainSize = new Temple[n];
     
    for(int i = 0; i < n; ++i)
    {
        chainSize[i] = new Temple();
        chainSize[i].L = -1;
        chainSize[i].R = -1;
    }
  
    // Values corner temples
    chainSize[0].L = 1;
    chainSize[n - 1].R = 1;
  
    // Filling left and right values
    // using same values of
    // previous(or next)
    for(int i = 1; i < n; ++i)
    {
        if (templeHeight[i - 1] < templeHeight[i])
            chainSize[i].L = chainSize[i - 1].L + 1;
        else
            chainSize[i].L = 1;
    }
    for(int i = n - 2; i >= 0; --i)
    {
        if (templeHeight[i + 1] < templeHeight[i])
            chainSize[i].R = chainSize[i + 1].R + 1;
        else
            chainSize[i].R = 1;
    }
  
    // Computing max of left and right for all
    // temples and returing sum.
    int sum = 0;
    for(int i = 0; i < n; ++i)
        sum += Math.Max(chainSize[i].L,
                        chainSize[i].R);
                         
    return sum;
}
 
// Driver code
static void Main()
{
    int []arr1 = { 1, 2, 2 };
    Console.Write(offeringNumber(3, arr1) + "\n");
 
    int []arr2 = { 1, 4, 3, 6, 2, 1 };
    Console.Write(offeringNumber(6, arr2) + "\n");
}
}
 
// This code is contributed by rutvik_56

输出：

4
10

时间复杂度： O(n)
空间复杂度： O(n)