【暑假】[深入动态规划]UVa 1412 Fund Management

UVa 1412 Fund Management

题目：

UVA - 1412

Fund Management

Time Limit: 3000MS

Memory Limit: Unknown

64bit IO Format: %lld & %llu

Submit Status

Description

 

Frank is a portfolio manager of a closed-end fund for Advanced Commercial Markets (ACM ). Fund collects money (cash) from individual investors for a certain period of time and invests cash into various securities in accordance with fund's investment strategy. At the end of the period all assets are sold out and cash is distributed among individual investors of the fund proportionally to their share of original investment.

Frank manages equity fund that invests money into stock market. His strategy is explained below.

Frank's fund has collected c<tex2html_verbatim_mark> US Dollars (USD) from individual investors to manage them for m<tex2html_verbatim_mark> days. Management is performed on a day by day basis. Frank has selected n<tex2html_verbatim_mark> stocks to invest into. Depending on the overall price range and availability of each stock, a lot size was chosen for each stock -- the number of shares of the stock Frank can buy or sell per day without affecting the market too much by his trades. So, if the price of the stock is p_i<tex2html_verbatim_mark> USD per share and the lot size of the corresponding stock is s_i<tex2html_verbatim_mark> , then Frank can spend p_is_i<tex2html_verbatim_mark> USD to buy one lot of the corresponding stock for his fund if the fund has enough cash left, thus decreasing available cash in the fund. This trade is completely performed in one day.

When price of the stock changes to p'_i<tex2html_verbatim_mark> later, then Frank can sell this lot for p'_is_i<tex2html_verbatim_mark> USD, thus increasing available cash for further trading. This trade is also completely performed in one day. All lots of stocks that are held by the fund must be sold by the end of the fund's period, so that at the end (like at the beginning) the fund is holding only cash.

Each stock has its own volatility and risks, so to minimize the overall risk of the fund, for each stock there is the maximum number of lots k_i<tex2html_verbatim_mark> that can be held by the fund at any given day. There is also the overall limit k<tex2html_verbatim_mark> on the number of lots of all stocks that the fund can hold at any given day.

Any trade to buy or sell one lot of stock completely occupies Frank's day, and thus he can perform at most one such trade per day. Frank is not allowed to buy partial lots if there is not enough cash in the fund for a whole lot at the time of purchase.

Now, when fund's period has ended, Frank wants to know what is the maximum profit he could have made with this strategy having known the prices of each stock in advance. Your task is to write a program to find it out.

It is assumed that there is a single price for each stock for each day that Frank could have bought or sold shares of the stock at. Any overheads such as fees and commissions are ignored, and thus cash spent to buy or gained on a sell of one lot of stock is exactly equal to its price on this day multiplied by the number of shares in a lot.

Input

Input consists on several datasets. The first line of each dataset contains four numbers -- c<tex2html_verbatim_mark> , m<tex2html_verbatim_mark> , n<tex2html_verbatim_mark> , and k<tex2html_verbatim_mark> . Here c<tex2html_verbatim_mark>(0.01c100000000.00)<tex2html_verbatim_mark> is the amount of cash collected from individual investors up to a cent (up to two digits after decimal point); m<tex2html_verbatim_mark>(1m100)<tex2html_verbatim_mark> is the number of days in the fund's lifetime; n<tex2html_verbatim_mark>(1n8)<tex2html_verbatim_mark> is the number of stocks selected by Frank for trading;k<tex2html_verbatim_mark>(1k8)<tex2html_verbatim_mark> is the overall limit on the number of lots the fund can hold at any time.

The following 2n<tex2html_verbatim_mark> lines describe stocks and their prices with two lines per stock.

The first line for each stock contains the stock name followed by two integer numbers s_i<tex2html_verbatim_mark> and k_i<tex2html_verbatim_mark> . Here s_i<tex2html_verbatim_mark>(1s_i1000000)<tex2html_verbatim_mark> is the lot size of the given stock, and k_i<tex2html_verbatim_mark>(1k_ik)<tex2html_verbatim_mark> is the number of lots of this stock the fund can hold at any time. Stock name consists of 1 to 5 capital Latin letters from `` A" to `` Z". All stock names in the input file are distinct.

The second line for each stock contains m<tex2html_verbatim_mark> decimal numbers separated by spaces that denote prices of the corresponding stock for each day in the fund's lifetime. Stock prices are in range from 0.01 to 999.99 (inclusive) given up to a cent (up to two digits after decimal point).

Cash and prices in the input file are formatted as a string of decimal digits, optionally followed by a dot with one or two digits after a dot.

Output

For each dataset, write to the output file m + 1<tex2html_verbatim_mark> lines. Print a blank line between datasets.

On the first line write a single decimal number -- the precise value for the maximal amount of cash that can be collected in the fund by the end of its period. The answer will not exceed 1 000 000 000.00. Cash must be formatted as a string of decimal digits, optionally followed by a dot with one or two digits after a dot.

On the following m<tex2html_verbatim_mark> lines write the description of Frank's actions for each day that he should have made in order to realize this profit. Write BUY followed by a space and a stock name for buying a stock. Write SELL followed by a space and a stock name for selling a stock. Write HOLD if nothing should have been done on that day.

Sample Input

144624.00 9 5 3
IBM 500 3
97.27 98.31 97.42 98.9 100.07 98.89 98.65 99.34 100.82
GOOG 100 1
467.59 483.26 487.19 483.58 485.5 489.46 499.72 505 504.28
JAVA 1000 2
5.54 5.69 5.6 5.65 5.73 6 6.14 6.06 6.06
MSFT 250 1
29.86 29.81 29.64 29.93 29.96 29.66 30.7 31.21 31.16
ORCL 300 3
17.51 17.68 17.64 17.86 17.82 17.77 17.39 17.5 17.3

Sample Output

151205.00
BUY GOOG
BUY IBM
BUY IBM
HOLD
SELL IBM
BUY MSFT
SELL MSFT
SELL GOOG
SELL IBM

思路：

一共有n天，把天数看作阶段，对于每一天，我们可以选择出手或买进一手股票，在最后一天必须将股票全部出手且求解最大钱数。

可以这样定义d[i][s]：表示第i天手中股票的状态为s时手中的最大钱数，采用刷表法更新d[i+1][s'] ，s'表示s经过出手或买进转移的状态。

问题就变成了如何表示状况s？采用n元组的形式。

但不能将一个n元组表示进d数组，这里的方法是离线dfs出全部状态并分别编号，得出状态与相连的关系buy_next与sell_next。那么d中的状态s就可以用一个整数表示了。

另外输出也有一定的技巧，用到了prev 与 opt 数组，并用正负区别操作。

代码(from Rujia Liu)：

 #include<cstdio>
 #include<cstring>
 #include<vector>
 #include<map>
 using namespace std;

 const double INF = 1e30;
 const int maxn = ;
 const int maxm =  + ;
 const int maxstate = ;

 int m, n, s[maxn], k[maxn], kk;
 double c, price[maxn][maxm];
 char name[maxn][];

 double d[maxm][maxstate];
 int opt[maxm][maxstate], prev[maxm][maxstate];    //配合输出print_ans 

 int buy_next[maxstate][maxn], sell_next[maxstate][maxn];
 vector<vector<int> > states;
 //states[i]代表一个标号为i的n元组  组信息用vector保存 //一个n元组带包手持各股票的数目
 map<vector<int>, int> ID;                        //ID 是vector到序号的映射 

 void dfs(int stock, vector<int>& lots, int totlot) {  //dfs序构造states
   if(stock == n) {              //新的n元组构造完成
     ID[lots] = states.size();   //ID
     states.push_back(lots);     //push
   }
   else for(int i = ; i <= k[stock] && totlot + i <= kk; i++) {   //在满足k[]与K的限制下如果可行则dfs下一stock
     lots[stock] = i;
     dfs(stock+, lots, totlot + i);    //回溯 写法
   }
 }

 void init() {    //利用states离线建立状态之间的关系
   vector<int> lots(n);
   states.clear();  //clear1
   ID.clear();      //clear2
   dfs(, lots, );  //return states
   for(int s = ; s < states.size(); s++) {   //操作一个状态
     int totlot = ;
     for(int i = ; i < n; i++) totlot += states[s][i];  //目前状态的所有股数
     for(int i = ; i < n; i++) {             //枚举在状态中改变的股票i
       buy_next[s][i] = sell_next[s][i] = -;   //初值-1
       if(states[s][i] < k[i] && totlot < kk) { //如果buy可行
         vector<int> newstate = states[s];
         newstate[i]++;
         buy_next[s][i] = ID[newstate];
       }
       if(states[s][i] > ) {                //如果sell可行
         vector<int> newstate = states[s];
         newstate[i]--;
         sell_next[s][i] = ID[newstate];
       }
     }
   }
 }

 void update(int day, int s, int s2, double v, int o) {  //刷表法 更新
 //在第day天 在进行操作后 状况s转移到状况s2 转移后手中钱数为v
 //对|o|进行操作      //opt的正负用以区分操作 buy || sell
   if(v > d[day+][s2]) {
     d[day+][s2] = v;
     opt[day+][s2] = o;    //: 得出 [][] 的最优操作
     prev[day+][s2] = s;   //: 得出 [][] 的最优前状况
   }
 }

 double dp() {
   for(int day = ; day <= m; day++)
     for(int s = ; s < states.size(); s++) d[day][s] = -INF //边界设定 

   d[][] = c;          //第0天手持0手股票 手中有c的钱数
   for(int day = ; day < m; day++)              //枚举天数
     for(int s = ; s < states.size(); s++) {    //枚举手中股票的状态
       double v = d[day][s];
       if(v < -) continue;  //return 

       update(day, s, s, v, ); // HOLD
       for(int i = ; i < n; i++) {
         if(buy_next[s][i] >=  && v >= price[i][day] - 1e-)       //s状态下要买股票i
           update(day, s, buy_next[s][i], v - price[i][day], i+); // BUY
         if(sell_next[s][i] >= )                                   //s状态下要卖股票i
           update(day, s, sell_next[s][i], v + price[i][day], -i-); // SELL
       }
     }
   return d[m][];    //到了第m天 手中没有股票 //反对DP原问题的最大值
 }

 void print_ans(int day, int s) {   //根据prev与opt递归输出解
   if(day == ) return;
   print_ans(day-, prev[day][s]);
   if(opt[day][s] == ) printf("HOLD\n");   //==0
   else if(opt[day][s] > ) printf("BUY %s\n", name[opt[day][s]-]);  // >0
   else printf("SELL %s\n", name[-opt[day][s]-]);                    //<0
 }

 int main() {
   int kase = ;
   while(scanf("%lf%d%d%d", &c, &m, &n, &kk) == ) {
     if(kase++ > ) printf("\n");

     for(int i = ; i < n; i++) {
       scanf("%s%d%d", name[i], &s[i], &k[i]);
       for(int j = ; j < m; j++) { scanf("%lf", &price[i][j]); price[i][j] *= s[i]; }
     }
     init();

     double ans = dp();
     printf("%.2lf\n", ans);
     print_ans(m, );
   }
   return ;
 }