找到购买所有书籍的最低成本

给定 n 本书的评分数组。在以下条件下找到购买所有书籍的最低成本：

1. 每本书的成本将至少为 1 美元。
2. 如果评级高于相邻，则一本书的成本高于相邻（左或右）。

例子 ：

Input : Ratings[] = {1, 3, 4, 3, 7, 1}
Output : 10
Exp :- 1 + 2 + 3 + 1 + 2 + 1 = 10

Input : ratings[] = {1, 6, 8, 3, 4, 1, 5, 7}
Output : 15
Exp :- 1 + 2 + 3 + 1 + 2 + 1 + 2 + 3 = 15 

1. 制作两个数组 left2right 和 right2left 并在它们中填充 1。
2. 从左到右遍历并填充 left2right 数组并通过查看给定数组的先前评级来更新它。不关心给定数组的下一个评级。
3. 从右到左遍历并填充 right2left 数组并通过查看给定数组的下一个评级来更新它。不关心给定数组的先前评级。
4. 在两个数组（left2right 和 right2left）中找到第 i 个位置的最大值并将其添加到结果中

C++

// C++ program to find minimum cost to buy
// n books.
#include 
using namespace std;
 
int minCost(int ratings[], int n)
{
    int res = 0;
    int left2right[n];
    int right2left[n];
 
    // fill 1 in both array
    fill_n(left2right, n, 1);
    fill_n(right2left, n, 1);
 
    // Traverse from left to right and assign
    // minimum possible rating considering only
    // left adjacent
    for (int i = 1; i < n; i++)
        if (ratings[i] > ratings[i - 1])
            left2right[i] = left2right[i - 1] + 1;    
 
    // Traverse from right to left and assign
    // minimum possible rating considering only
    // right adjacent
    for (int i = n - 2; i >= 0; i--)
        if (ratings[i] > ratings[i + 1])
            right2left[i] = right2left[i + 1] + 1;      
     
    // Since we need to follow rating rule for
    // both adjacent, we pick maximum of two
    for (int i = 0; i < n; i++)
        res += max(left2right[i], right2left[i]);
     
    return res;
}
 
// Driver function
int main()
{
    int ratings[] = { 1, 6, 8, 3, 4, 1, 5, 7 };
    int n = sizeof(ratings) / sizeof(ratings[0]);
    cout << minCost(ratings, n);
    return 0;
}

Java

// JAVA Code For Find minimum cost to
// buy all books
import java.util.*;
 
class GFG {
     
    public static int minCost(int ratings[], int n)
    {
        int res = 0;
        int left2right[] = new int[n];
        int right2left[] = new int[n];;
      
        // fill 1 in both array
        Arrays.fill(left2right,  1);
        Arrays.fill(right2left, 1);
      
        // Traverse from left to right and assign
        // minimum possible rating considering
        // only left adjacent
        for (int i = 1; i < n; i++)
            if (ratings[i] > ratings[i - 1])
                left2right[i] = left2right[i - 1] + 1;    
      
        // Traverse from right to left and assign
        // minimum possible rating considering only
        // right adjacent
        for (int i = n - 2; i >= 0; i--)
            if (ratings[i] > ratings[i + 1])
                right2left[i] = right2left[i + 1] + 1;      
          
        // Since we need to follow rating rule for
        // both adjacent, we pick maximum of two
        for (int i = 0; i < n; i++)
            res += Math.max(left2right[i],
                            right2left[i]);
          
        return res;
    }
     
    /* Driver program to test above function */
    public static void main(String[] args)
    {
        int ratings[] = { 1, 6, 8, 3, 4, 1, 5, 7 };
        int n = ratings.length;
        System.out.print(minCost(ratings, n));
         
    }
}
   
// This code is contributed by Arnav Kr. Mandal.

Python

# Python program to find minimum cost to buy
# n books.
 
def minCost(ratings, n):
    res = 0
    
    # fill 1 in both array
    left2right = [1 for i in range(n)]
    right2left = [1 for i in range(n)]
  
    # Traverse from left to right and assign
    # minimum possible rating considering only
    # left adjacent
    for i in range(1, n):
        if (ratings[i] > ratings[i - 1]):
            left2right[i] = left2right[i - 1] + 1
  
    # Traverse from right to left and assign
    # minimum possible rating considering only
    # right adjacent
    i = n - 2
    while(i >= 0):
        if (ratings[i] > ratings[i + 1]):
            right2left[i] = right2left[i + 1] + 1
        i -= 1
      
    # Since we need to follow rating rule for
    # both adjacent, we pick maximum of two
    for i in range(n):
         
        res += max(left2right[i], right2left[i])
      
    return res
  
# Driver function
ratings = [ 1, 6, 8, 3, 4, 1, 5, 7 ]
n = len(ratings)
print minCost(ratings, n)
 
# This code is contributed by Sachin Bisht

C#

// C# code For Finding minimum
// cost to buy all books
using System;
 
class GFG {
     
    public static int minCost(int []ratings, int n)
    {
        int res = 0;
        int []left2right = new int[n];
        int []right2left = new int[n];
     
        // fill 1 in both array
        for(int i = 0; i < n; i++)
        left2right[i] = 1;
         
        for(int i = 0; i < n; i++)
        right2left[i] = 1;
     
        // Traverse from left to right and assign
        // minimum possible rating considering
        // only left adjacent
        for (int i = 1; i < n; i++)
            if (ratings[i] > ratings[i - 1])
                left2right[i] = left2right[i - 1] + 1;    
     
        // Traverse from right to left and assign
        // minimum possible rating considering only
        // right adjacent
        for (int i = n - 2; i >= 0; i--)
            if (ratings[i] > ratings[i + 1])
                right2left[i] = right2left[i + 1] + 1;    
         
        // Since we need to follow rating rule for
        // both adjacent, we pick maximum of two
        for (int i = 0; i < n; i++)
            res += Math.Max(left2right[i],
                            right2left[i]);
         
        return res;
    }
     
    /* Driver program to test above function */
    public static void Main()
    {
        int []ratings = {1, 6, 8, 3, 4, 1, 5, 7};
        int n = ratings.Length;
        Console.Write(minCost(ratings, n));
    }
}
     
// This code is contributed by nitin mittal.

Javascript

 
// JavaScript program to find minimum cost to buy
// n books.
 
function minCost(ratings, n) {
    let res = 0;
    let left2right = new Array(n).fill(1);
    let right2left = new Array(n).fill(1);
 
 
    // Traverse from left to right and assign
    // minimum possible rating considering only
    // left adjacent
    for (let i = 1; i < n; i++)
        if (ratings[i] > ratings[i - 1])
            left2right[i] = left2right[i - 1] + 1;
 
    // Traverse from right to left and assign
    // minimum possible rating considering only
    // right adjacent
    for (let i = n - 2; i >= 0; i--)
        if (ratings[i] > ratings[i + 1])
            right2left[i] = right2left[i + 1] + 1;
 
    // Since we need to follow rating rule for
    // both adjacent, we pick maximum of two
    for (let i = 0; i < n; i++)
        res += Math.max(left2right[i], right2left[i]);
 
    return res;
}
 
// Driver function
 
let ratings = [1, 6, 8, 3, 4, 1, 5, 7];
let n = ratings.length;
document.write(minCost(ratings, n));
 

输出：

15