Treats for the Cows

问题描述

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

43 

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>