C++——【USACO 4.3.1】——Buy Low, Buy Lower

Buy Low, Buy Lower

The advice to "buy low" is half the formula to success in the stock market. But to be considered a great investor you must also follow this problems' advice:

"Buy low, buy lower"

That is, each time you buy a stock, you must purchase more at a lower price than the previous time you bought it. The more times you buy at a lower price than before, the better! Your goal is to see how many times you can continue purchasing at ever lower prices.

You will be given the daily selling prices of a stock over a period of time. You can choose to buy stock on any of the days. Each time you choose to buy, the price must be lower than the previous time you bought stock. Write a program which identifies which days you should buy stock in order to maximize the number of times you buy.

By way of example, suppose on successive days stock is selling like this:

 Day   1  2  3  4  5  6  7  8  9 10 11 12
Price 68 69 54 64 68 64 70 67 78 62 98 87

In the example above, the best investor (by this problem, anyway) can buy at most four times if they purchase at a lower price each time. One four day sequence (there might be others) of acceptable buys is:

Day    2  5  6 10
Price 69 68 64 62

PROGRAM NAME: buylow

INPUT FORMAT

Line 1:	N (1 <= N <= 5000), the number of days for which stock prices are available.
Line 2..etc:	A series of N positive space-separated integers (which may require more than one line of data) that tell the price for that day. The integers will fit into 32 bits quite nicely.

SAMPLE INPUT (file buylow.in)

12
68 69 54 64 68 64 70 67
78 62 98 87

OUTPUT FORMAT

Two integers on a single line:

• the length of the longest sequence of decreasing prices
• the number of sequences that have this length

In counting the number of solutions, two potential solutions are considered the same (and would only count as one solution) if they repeat the same string of decreasing prices, that is, if they "look the same" when the successive prices are compared. Thus, two different sequence of "buy" days could produce the same string of decreasing prices and be counted as only a single solution.

SAMPLE OUTPUT (file buylow.out)

4 2“低买”的建议是股市成功的一半。但要被认为是一个伟大的投资者，你必须遵循这个问题的建议:

低价购买

也就是说，每次你买股票的时候，你必须以比你上次买的价格更低的价格购买更多的股票。你买的价格比以前低了，那就更好了!你的目标是看到你能以更低的价格继续购买多少次。
在一段时间内，你将得到股票的每日销售价格。你可以选择在任何时候购买股票。每次你选择购买的时候，价格都必须低于你上次买股票的时间。编写一个程序，用来确定你应该购买哪些日子，以便最大化你购买的次数。
举例来说，假设连续几天的股票是这样卖的:
第一天2 3 4 5 6 7 8 9 10 11 12
价格为68 669 54 64 68 64 70 6778 62 98 87
在上面的例子中，最好的投资者(无论如何)如果每次都以较低的价格购买，最多可以购买四次。一个4天序列(可能还有其他)可能的购买是:
第    2   5   6  10  天
价格69 68 64 62
项目名称:buylow
输入格式
第1行:N(1 <= N <= 5000)，天数。
第2行. .等等:一系列的N个正空间分隔的整数(可能需要超过一行的数据)来说明当天的价格。这些整数在32位之内。
示例输入(文件buylow.in)
12个
68 69 54 64 68 64 70 67
78 62 98 87
输出格式
单线上的两个整数:
持续时间最长的降低价格序列的长度
有这个长度的序列的数目
在计算解决方案的数量时，两个潜在的解决方案被认为是相同的(而且只有一个解决方案)，如果它们重复相同的价格下降的字符串，那就是，如果它们在连续的价格被比较时“看起来相同”。因此，两种不同的“买入”天数可以产生同样的价格下跌，并被视为唯一的解决方案。
样例输出(文件buylow.out)
4 2

/*
ID : mcdonne1
LANG : C++
TASK : buylow
*/

#pragma GCC optimize("O3")

#include <cstdio>

int n,maxx,num;
int a[5002],b[5002];
long long f[5002];
bool ok[50002];

int main () {
	freopen ("buylow.in", "r", stdin);
	freopen ("buylow.out", "w", stdout);
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	b[1]=1;
    f[1]=1;
    for(int i=2;i<=n+1;i++)
    {
    	maxx=0;
    	f[i]=1;
    	for(int j=i-1;j>=1;j--)
    		if(a[i]<a[j])
    			if(b[j]>maxx)
    			{
    				maxx=b[j];
    				for(int k=0;k<=50001;k++) ok[k]=true;
    				ok[a[j]]=false;
    				f[i]=f[j];
    			}
    			else if(b[j]==maxx&&ok[a[j]])
    			{
    				ok[a[j]]=false;
    				f[i]+=f[j];
    			}
    	b[i]=maxx+1;
    }
    if(f[n+1] == 0) printf("%d 1606938044258990275541962092341162602522202993782792835301376\n",b[n+1]-1);
    else printf("%d %lld\n", b[n+1]-1, f[n+1]);
    return 0;
}