USACO Section 4.3 Buy low,Buy lower

第一眼看到题目,感觉水水的,不就是最长下降子序列嘛!然后写……就呵呵了..要判重,还要高精度……判重我是在计算中加入各种判断。这道题比看上去麻烦一点,但其实还好吧..

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

#define rep(i,l,r) for(int i=l;i<r;i++)
#define clr(x,c) memset(x,c,sizeof(x))

using namespace std;

const int inf=0x3f3f3f3f,maxn=5000+5,maxv=100;
int c[maxn],mdp[maxn],MDP[maxn][maxv];

int dp(int i) {
    if(mdp[i]>0) return mdp[i];
    int ans=0;
    rep(j,0,i) if(c[j]>c[i]) ans=max(dp(j),ans);
    return mdp[i]=ans+1;
}

int main() {
    freopen("buylow.in","r",stdin);
    freopen("buylow.out","w",stdout);

    int n;
    cin>>n;
    rep(i,0,n) scanf("%d",&c[i]);
    clr(mdp,0); mdp[0]=1;
    clr(MDP,0);
    MDP[0][1]=1; MDP[0][0]=1;
    rep(i,1,n)
        if(dp(i)==1) {
            int pd=0;
            rep(j,0,i) if(c[j]==c[i] && dp(i)==dp(j)) pd=1;
            if(!pd) { MDP[i][0]=1; MDP[i][1]=1; }
        }
        else {
            int r=0;
            rep(j,0,i) if(dp(j)==dp(i) && c[i]==c[j]) r=j+1;
            rep(j,r,i) if(dp(j)+1==dp(i) && c[j]>c[i]) {
                int t=max(MDP[i][0],MDP[j][0]);
                rep(k,1,t+1) MDP[i][k]+=MDP[j][k];
                rep(k,1,t+1) if(MDP[i][k]/10) {
                    MDP[i][k+1]+=MDP[i][k]/10;
                    MDP[i][k]%=10;
                }
                while(MDP[i][++t]) if(MDP[i][t]/10) {
                    MDP[i][t+1]+=MDP[i][t]/10;
                    MDP[i][t]%=10;
                }
                MDP[i][0]=--t;
            }
        }

    int ans=-1,cnt[maxv];
    clr(cnt,0);
    rep(i,0,n) ans=max(dp(i),ans);
    rep(i,0,n) if(ans==dp(i)) {
        int t=max(cnt[0],MDP[i][0]);
        rep(j,1,t+1) cnt[j]+=MDP[i][j];
        rep(j,1,t+1) if(cnt[j]/10) {
            cnt[j+1]+=cnt[j]/10;
            cnt[j]%=10;
        }
        while(cnt[++t])
            if(cnt[t]/10) {
                cnt[t+1]+=cnt[t]/10;
                cnt[t]%=10;
            }
        cnt[0]=--t;
    }
    cout<<ans<<‘ ‘;
    for(int i=cnt[0];i>0;i--) cout<<cnt[i];
    cout<<endl;

    return 0;
}

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
时间: 2024-10-13 16:20:10

USACO Section 4.3 Buy low,Buy lower的相关文章

算法练习 - Buy Low, Buy Lower - USACO

这道题目本身很简单,倒推回去,第K个是最优时,K+1时必然包含它.所以就从最后面的股票开始贪心法用最优解生成最优解. 难点1是去重,我直接用了个价格表去过滤,如果多个价格相等的同级最优解,就用他们中可能性最大的那个累加,其余的忽略. 难点2是大数计算.可能性可能有几十位的数字,所以封装了一个大数类.现在还不支持符号,只支持正数.后面需要用到负数的时候再说. 题目: Buy Low, Buy Lower The advice to "buy low" is half the formul

【dp】PKU 1952 buy low,buy lower

题目链接: http://poj.org/problem?id=1952 Usaco 4.3.1 Buy Low, Buy Lower By 小兔齐齐 描述 “逢低吸纳”是炒股的一条成功秘诀.如果你想成为一个成功的投资者,就要遵守这条秘诀: "逢低吸纳,越低越买" 这句话的意思是:每次你购买股票时的股价一定要比你上次购买时的股价低.按照这个规则购买股票的次数越多越好,看看你最多能按这个规则买几次. 给定连续的N天中每天的股价.你可以在任何一天购买一次股票,但是购买时的股价一定要比你上次

POJ 1952 BUY LOW, BUY LOWER 动态规划题解

Description The advice to "buy low" is half the formula to success in the bovine stock market.To be considered a great investor you must also follow this problems' advice: "Buy low; buy lower" Each time you buy a stock, you must purcha

poj 1952 BUY LOW, BUY LOWER (最长递减子序列+不同子序列计数)

BUY LOW, BUY LOWER Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 8327   Accepted: 2888 Description The advice to "buy low" is half the formula to success in the bovine stock market.To be considered a great investor you must also f

POJ 1952 BUY LOW, BUY LOWER

BUY LOW, BUY LOWER Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 8311   Accepted: 2883 Description The advice to "buy low" is half the formula to success in the bovine stock market.To be considered a great investor you must also f

poj 1952 BUY LOW, BUY LOWER 最长下降子序列+统计不重复方案数

dp[i]=max(dp[i],dp[j]+1) j<i且a[j]>a[i] dp[i]表示长度为i的最长下降子序列的长度. r[i]表示长度为i的最长下降子序列的方案数. 考虑这样一个问题,比如6 3 9 3,对于两个3,他们数字一样并且dp值也一样,那么r[2]的方案数是没有意义的 因为能通过第一个3扩展的也能通过第二个3扩展,所以直接把r[2]=0. 对于一次扩展若dp[j]+1==dp[i],则说明j的路线和i的路线都可以用则r[i]+=r[j] 若dp[j]+1>dp[i],则

[POJ1952]BUY LOW, BUY LOWER

题目描述 Description The advice to "buy low" is half the formula to success in the bovine stock market.To be considered a great investor you must also follow this problems' advice: "Buy low; buy lower" Each time you buy a stock, you must p

poj 1952 BUY LOW, BUY LOWER[最长单调子序列变形]

题目:poj 1952 BUY LOW, BUY LOWER 题意:给出一个序列,先求最长单调递减子序列,然后求在子序列最长的情况下,不同的长度都为最长的的子序列的个数.(比如3,2,1和3,2,1属于相同,只能算一个) 分析:首先用一个dp[i]表示到当前i点的最长子序列的长度 用dp2[i]表示最长为dp[i]的子序列的个数 然后dp[i] = max(dp[j])+1 (1<=j /************************************ Problem: 1952 Use

POJ 1552 BUY LOW, BUY LOWER(最长单调递减子序列求方案数)

BUY LOW, BUY LOWER Time Limit: 1000MS   Memory Limit: 30000K       Description The advice to "buy low" is half the formula to success in the bovine stock market.To be considered a great investor you must also follow this problems' advice: "