尽量减少要分发的泰迪熊的总数

给定 N 个学生排成一排，每个人都有他们在考试中获得的分数。任务是在满足给定条件时分发泰迪熊

1. 所有学生必须至少拥有 1 个泰迪熊
2. 如果两个学生并排坐着，那么分数较高的那个必须得到更多的泰迪熊。

因此，任务是最小化泰迪熊的总数。
例子：

Input: n = 3, marks = [ 1, 2, 2 ]
Output: 4
Here 1, 2, 2 is the marks. 
Note that when two students have equal marks 
they are allowed to have a different number of teddies. 
Hence optimal distribution will be 1, 2, 1.

Input: n = 6, marks = [ 1, 4, 5, 2, 2, 1 ]
Output: 10

方法：方法是使用动态规划来解决给定的问题：

1. 初始化大小为 n 的表。
2. 运行循环 n 次。
3. 如果左边的相邻学生得分较高，请查看并更改之前分配的所有表值作为解决方案，直到根据给定的约束发现分配的表值作为解决方案是错误的。
4. 如果右邻学生得分较高，则在左邻学生的解决方案中加一，并分配给右邻学生的解决方案。

下面是上述方法的实现：

C++

// C++ implementation of the
// above approach
#include
using namespace std;
 
long long fun(int marks[],int n)
{
    // Initializing one tablet
    // for each student
    long long dp[n], temp;
    fill(dp, dp + n, 1);
     
    for(int i = 0; i < n - 1; i++)
    {
        // if left adjacent is having
        // higher marks review and change
        // all the dp values assigned before
        // until assigned dp values are found
        // wrong according to given constrains
        if (marks[i] > marks[i + 1])
        {
            temp = i;
            while (true)
            {
                if ((marks[temp] > marks[temp + 1]) &&
                                         temp >= 0)
                {
                    if (dp[temp] > dp[temp + 1])
                    {
                        temp -= 1;
                        continue;
                    }
                    else
                    {
                        dp[temp] = dp[temp + 1] + 1;
                        temp -= 1;
                    }
                }                    
                else
                    break;
            }
        }
         
        // if right adjacent is having higher
        // marks add one in dp of left adjacent
        // and assign to right one
        else if( marks[i] < marks[i + 1])
            dp[i + 1] = dp[i] + 1;
    }
 
    int sum = 0;
 
    for(int i = 0; i < n; i++)
    sum += dp[i];
 
    return sum;
}
 
// Driver Code
int main()
{
    // n number of students
    int n = 6;
     
    // marks of students
    int marks[6] = { 1, 4, 5, 2, 2, 1};
     
    // solution of problem
    cout << fun(marks, n);
     
    return 0;
}
 
// This code is contributed by ash264

Java

// Java implementation of the
// above approach
 
public class GFG {
 
    static long fun(int marks[],int n)
    {
        // Initializing one tablet 
        // for each student
        long dp[] = new long[n] ;
        int temp;
         
        for (int i = 0;i < n;i ++)
            dp[i] = 1 ;
           
        for(int i = 0; i < n - 1; i++)
        {
            // if left adjacent is having 
            // higher marks review and change 
            // all the dp values assigned before
            // until assigned dp values are found 
            // wrong according to given constrains
            if (marks[i] > marks[i + 1])
            { 
                temp = i;
                while (true)
                {
                    if ((marks[temp] > marks[temp + 1]) && 
                                             temp >= 0)
                    {
                        if (dp[temp] > dp[temp + 1])
                        {
                            temp -= 1;
                            continue;
                        }
                        else
                        {
                            dp[temp] = dp[temp + 1] + 1;
                            temp -= 1;
                        }
                    }                    
                    else
                        break; 
                } 
            }
               
            // if right adjacent is having higher
            // marks add one in dp of left adjacent
            // and assign to right one
            else if( marks[i] < marks[i + 1])
                dp[i + 1] = dp[i] + 1;
        }
       
        int sum = 0;
       
        for(int i = 0; i < n; i++)
        sum += dp[i];
       
        return sum;
    }
     
    public static void main(String args[])
    {
        // n number of students
        int n = 6;
           
        // marks of students
        int marks[] = { 1, 4, 5, 2, 2, 1};
           
        // solution of problem
        System.out.println(fun(marks, n));
    }
    // This code is contributed by ANKITRAI1
}

Python 3

# Python implementation of the above approach
 
def fun(marks, n):
    # Initializing one tablet for each student
    dp = [ 1 for i in range(0, n) ]
 
    for i in range(0, n-1):
 
        # if left adjacent is having higher marks
        # review and change all the dp values assigned before
        # until assigned dp values are found wrong
        # according to given constrains
        if marks[i] > marks[i + 1]:
            temp = i
            while True:
                if marks[temp] > marks[temp + 1] and temp >= 0:
                    if dp[temp] > dp[temp + 1]:
                        temp -= 1
                        continue
                    else:
                        dp[temp] = dp[temp + 1] + 1
                        temp -= 1                       
                else:
                    break   
 
        # if right adjacent is having higher marks
        # add one in dp of left adjacent and assign to right one
        elif marks[i] < marks[i + 1]:
            dp[i + 1] = dp[i] + 1
 
    return(sum(dp))
 
 
 
# driver code
 
# n number of students
n = 6
 
# marks of students
marks = [ 1, 4, 5, 2, 2, 1]
 
# solution of problem
print(fun(marks, n))

C#

// C# implementation of the
// above approach
using System;
   
class GFG
{
    public static long fun(int[] marks,int n)
    {
        // Initializing one tablet 
        // for each student
        long[] dp = new long[n];
        long temp;
         
        for(int i = 0; i < n; i++)
            dp[i] = 1;
           
        for(int i = 0; i < n - 1; i++)
        {
            // if left adjacent is having 
            // higher marks review and change 
            // all the dp values assigned before
            // until assigned dp values are found 
            // wrong according to given constrains
            if (marks[i] > marks[i + 1])
            { 
                temp = i;
                while (true)
                {
                    if ((marks[temp] > marks[temp + 1]) && 
                                             temp >= 0)
                    {
                        if (dp[temp] > dp[temp + 1])
                        {
                            temp -= 1;
                            continue;
                        }
                        else
                        {
                            dp[temp] = dp[temp + 1] + 1;
                            temp -= 1;
                        }
                    }                     
                    else
                        break; 
                } 
            }
               
            // if right adjacent is having higher
            // marks add one in dp of left adjacent
            // and assign to right one
            else if( marks[i] < marks[i + 1])
                dp[i + 1] = dp[i] + 1;
        }
       
        long sum = 0;
       
        for(int i = 0; i < n; i++)
            sum += dp[i];
       
        return sum;
    }
       
    // Driver Code
    static void Main()
    {
        // n number of students
        int n = 6;
           
        // marks of students
        int[] marks = new int[]{ 1, 4, 5, 2, 2, 1};
           
        // solution of problem
        Console.Write( fun(marks, n) ); 
    }
    //This code is contributed by DrRoot_
}

Javascript

    // Javascript implementation of the above approach
     
    function fun(marks, n)
    {
        // Initializing one tablet 
        // for each student
        let dp = new Array(n);
        let temp;
           
        for(let i = 0; i < n; i++)
            dp[i] = 1;
             
        for(let i = 0; i < n - 1; i++)
        {
            // if left adjacent is having 
            // higher marks review and change 
            // all the dp values assigned before
            // until assigned dp values are found 
            // wrong according to given constrains
            if (marks[i] > marks[i + 1])
            { 
                temp = i;
                while (true)
                {
                    if ((marks[temp] > marks[temp + 1]) && 
                                             temp >= 0)
                    {
                        if (dp[temp] > dp[temp + 1])
                        {
                            temp -= 1;
                            continue;
                        }
                        else
                        {
                            dp[temp] = dp[temp + 1] + 1;
                            temp -= 1;
                        }
                    }                     
                    else
                        break; 
                } 
            }
                 
            // if right adjacent is having higher
            // marks add one in dp of left adjacent
            // and assign to right one
            else if( marks[i] < marks[i + 1])
                dp[i + 1] = dp[i] + 1;
        }
         
        let sum = 0;
         
        for(let i = 0; i < n; i++)
            sum += dp[i];
         
        return sum;
    }
     
    // n number of students
    let n = 6;
 
    // marks of students
    let marks = [ 1, 4, 5, 2, 2, 1];
 
    // solution of problem
    document.write( fun(marks, n) ); 
 
// This code is contributed by divyesh072019.

输出：

10

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。