Treats for the Cows

最新推荐文章于 2024-05-19 15:55:45 发布

Shao Kaiyang

最新推荐文章于 2024-05-19 15:55:45 发布

阅读量777

点赞数 1

分类专栏： C-题解

本文链接：https://blog.csdn.net/Kaiyang_Shao/article/details/51317955

版权

C-题解专栏收录该内容

30 篇文章 4 订阅

订阅专栏

问题描述

Description

FJ has purchased N (1 <= N <= 2000) yummy treats for the cows who get money for giving vast amounts of milk. FJ sells one treat per day and wants to maximize the money he receives over a given period time.

The treats are interesting for many reasons:

The treats are numbered 1..N and stored sequentially in single file in a long box that is open at both ends. On any day, FJ can retrieve one treat from either end of his stash of treats.
Like fine wines and delicious cheeses, the treats improve with age and command greater prices.
The treats are not uniform: some are better and have higher intrinsic value. Treat i has value v(i) (1 <= v(i) <= 1000).
Cows pay more for treats that have aged longer: a cow will pay v(i)*a for a treat of age a.

Given the values v(i) of each of the treats lined up in order of the index i in their box, what is the greatest value FJ can receive for them if he orders their sale optimally?

The first treat is sold on day 1 and has age a=1. Each subsequent day increases the age by 1.

Input

Line 1: A single integer, N

Lines 2..N+1: Line i+1 contains the value of treat v(i)

Output

Line 1: The maximum revenue FJ can achieve by selling the treats

Sample Input

5 1 3 1 5 2

Sample Output

Hint

Explanation of the sample:

Five treats. On the first day FJ can sell either treat #1 (value 1) or treat #5 (value 2).

FJ sells the treats (values 1, 3, 1, 5, 2) in the following order of indices: 1, 5, 2, 3, 4, making 1x1 + 2x2 + 3x3 + 4x1 + 5x5 = 43.

Source

	测试输入	期待的输出	时间限制	内存限制	额外进程
测试用例 1	以文本方式显示 5↵ 1↵ 3↵ 1↵ 5↵ 2↵	以文本方式显示 43↵	1秒	64M	0

题解思路

题目等效含义：

给出一个数字序列，然后每次只可以从队首或是队尾取相应的数字并乘上次数，第几个取出，取出的元素就乘以几，然后将所有的乘完之后的元素加起来，求最大的和。

大致思路：

一开始的时候以为这道题就是一道贪心题目，因为对于样例贪心算法完全符合。但是交了之后才发现不对，例如这样一个用例8 1 9 7，如果按照贪心的思路是7*1+8*2+1*3+9*4=62，但是如果这样去9*4+7*3+1*2+8*1=67，显然贪心得到的结果是不对，所以就要利用动态规划的方法进行计算。我们可以利用由内到外的思路进行计算，在开始的时候假设每一个数字都可以是最后被取出的，然后依次向前利用动态规划进行计算，每一次比较前后乘以相应次数的结果的最大值，将其赋给当状态。最后输出dp[1][n]即可。

具体实现：

先将给出的数字存入一个数组里面，然后再定义一个二维数组表示相应的状态，用以记录取相应次数的时候得到的最大值。开始的时候假设每一个数字都可以是最后被取出的，然后利用一个两重循环，依此由内向外推即可。

注意事项：

（1）因为数字序列的长度比较大，所以定义的数组要当做全局变量，不然的话会re。

（2）状态转移方程注意数组的下标，注意数组下标的变换。

（3）注意最后的输出，根据自己的状态数组输出相应的一个值。

实现代码

<span style="font-family:Microsoft YaHei;font-size:14px;">#include<stdio.h>
#include<string.h>
int dp[2005][2005];
//int max(int x,int y)
//{
//	if(x>y)
//	return x;
//	return y;
//}
int main()
{
   int n,i,p,j;
   int jiazhi[2005];
   int temp1,temp2; 
    memset(dp,0,sizeof(dp));
   scanf("%d",&n);
       for(i=0;i<n;i++)
         {
             scanf("%d",&jiazhi[i]);
               dp[i][i]=jiazhi[i]*n;
         }
        for(p=1;p<=n;p++)
       {
           for(i=0;i<n-p;i++)
             {
                 j=i+p;
                 temp1=dp[i+1][j]+jiazhi[i]*(n-j+i);
                 temp2=dp[i][j-1]+jiazhi[j]*(n-j+i);
                // dp[i][j]=max(dp[i+1][j]+jiazhi[i]*(n-j+i),dp[i][j-1]+jiazhi[j]*(n-j+i));
                if(temp1>temp2)
                {
                	dp[i][j]=temp1;
                }
                else
                {
                	dp[i][j]=temp2;
                }
            }
       }
        printf("%d\n",dp[0][n-1]);
   
   return 0;
}</span>