C++博客-ACM___________________________-随笔分类-ACM ( DP )

HDOJ HDU 2059 龟兔赛跑 ACM 2059 IN HDU

MiYu — Fri, 06 Aug 2010 03:44:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=2059
题目描述:

Problem Description
据说在很久很久以前，可怜的兔子经历了人生中最大的打击——赛跑输给乌龟后，心中郁闷，发誓要报仇雪恨，于是躲进了杭州下沙某农业园卧薪尝胆潜心修炼，终于练成了绝技，能够毫不休息得以恒定的速度(VR m/s)一直跑。兔子一直想找机会好好得教训一下乌龟，以雪前耻。
最近正值HDU举办50周年校庆，社会各大名流齐聚下沙，兔子也趁此机会向乌龟发起挑战。虽然乌龟深知获胜希望不大，不过迫于舆论压力，只能接受挑战。
比赛是设在一条笔直的道路上，长度为L米，规则很简单，谁先到达终点谁就算获胜。
无奈乌龟自从上次获胜以后，成了名龟，被一些八卦杂志称为“动物界的刘翔”，广告不断，手头也有了不少积蓄。为了能够再赢兔子，乌龟不惜花下血本买了最先进的武器——“"小飞鸽"牌电动车。这辆车在有电的情况下能够以VT1 m/s的速度“飞驰”，可惜电池容量有限，每次充满电最多只能行驶C米的距离，以后就只能用脚来蹬了，乌龟用脚蹬时的速度为VT2 m/s。更过分的是，乌龟竟然在跑道上修建了很多很多（N个)的供电站，供自己给电动车充电。其中，每次充电需要花费T秒钟的时间。当然，乌龟经过一个充电站的时候可以选择去或不去充电。
比赛马上开始了，兔子和带着充满电的电动车的乌龟并列站在起跑线上。你的任务就是写个程序，判断乌龟用最佳的方案进军时，能不能赢了一直以恒定速度奔跑的兔子。

Input
本题目包含多组测试，请处理到文件结束。每个测试包括四行：
第一行是一个整数L代表跑道的总长度
第二行包含三个整数N，C，T，分别表示充电站的个数，电动车冲满电以后能行驶的距离以及每次充电所需要的时间
第三行也是三个整数VR，VT1，VT2，分别表示兔子跑步的速度，乌龟开电动车的速度，乌龟脚蹬电动车的速度
第四行包含了N(N<=100)个整数p1,p2pn,分别表示各个充电站离跑道起点的距离，其中0<p1<p2<<pn<L
其中每个数都在32位整型范围之内。

Output
当乌龟有可能赢的时候输出一行 “What a pity rabbit!"。否则输出一行"Good job,rabbit!";
题目数据保证不会出现乌龟和兔子同时到达的情况。

Sample Input
100
3 20 5
5 8 2
10 40 60
100
3 60 5
5 8 2
10 40 60

Sample Output
Good job,rabbit!
What a pity rabbit!

题目分析 :
         我们可以把起点终点以及其中的 n 个充电站, 看错 n + 2 个点 ( 这是关键 )
定义 bst[n+2] 的数组用来保存乌龟到达每个站的最短时间. 有题目分析可以知道
bst[0] = 0 ( 乌龟一开始就在这里,不用走 ). 接下来就依次DP 了.
    到了站点 i 时, 令 j 从 0 -> i -1 循环, 代表从 j 站充满电开到 i 站 . 这样就得到
了到达 i 站的最短时间.
         这里我们有状态转移方程:
                                    原来的写错了, 不知道怎么表达 . 谁知道的麻烦给我留下言,谢谢
代码如下 :

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋
#include <iostream>
int dis[102];
double bst[102];
int main()
{
       int L;
       while ( scanf( "%d", &L ) != EOF )
       {
           int vr, v1, v2, n, c, t;
                 scanf ( "%d%d%d", &n, &c, &t );
                 scanf ( "%d%d%d", &vr, &v1, &v2 );
                 bst[0] = dis[0] = 0;
                 for ( int i = 1; i <= n; ++ i )
                 {
                   scanf("%d", &dis[i] );
           }
                 dis[n + 1] = L;
                 for ( int i = 1; i != n+2; ++ i )
                 {
                          double min = 0xFFFFF;
                          for ( int j = 0; j != i; ++ j )
                          {
                                   int len = dis[i] - dis[j];
                                   double temp = len > c ? 1.0 * c / v1 + ( len - c ) * 1.0 / v2 : 1.0 * len / v1;  //乌龟满电从 j 充电站到 i 充电站所用的时间
                                   temp += bst[j];
                                   if ( j )      // 起点不用充电 ,别忘了哈, 要不真的很郁闷
                       {
                            temp += t;
                       }
                                   if ( min > temp ) // 取到达i站所用时间的最小值
                       {
                            min = temp;
                       }
                          }
                          bst[i] = min;   //保存到达第 I 站的最小值
                 }
                 puts ( 1.0 * L / vr > bst[n + 1] ? "What a pity rabbit!" : "Good job,rabbit!" );
       }

       return 0;
}

MiYu 2010-08-06 11:44 发表评论

HDOJ HDU 1176 免费馅饼 ACM 1176 IN HDU

MiYu — Thu, 05 Aug 2010 06:02:00 GMT

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
         http://acm.hdu.edu.cn/showproblem.php?pid=1176
题目描述:
         都说天上不会掉馅饼，但有一天gameboy正走在回家的小径上，忽然天上掉下大把大把的馅饼。说来gameboy的人品实在是太好了，这馅饼别处都不掉，就掉落在他身旁的10米范围内。馅饼如果掉在了地上当然就不能吃了，所以gameboy马上卸下身上的背包去接。但由于小径两侧都不能站人，所以他只能在小径上接。由于gameboy平时老呆在房间里玩游戏，虽然在游戏中是个身手敏捷的高手，但在现实中运动神经特别迟钝，每秒种只有在移动不超过一米的范围内接住坠落的馅饼。现在给这条小径如图标上坐标.
为了使问题简化，假设在接下来的一段时间里，馅饼都掉落在0-10这11个位置。开始时gameboy站在5这个位置，因此在第一秒，他只能接到4,5,6这三个位置中期中一个位置上的馅饼。问gameboy最多可能接到多少个馅饼？（假设他的背包可以容纳无穷多个馅饼）

很简单的一道 DP 题目, 初看起来似乎很难, 但是自习分析,会发现 , 这其实就是

                                          数塔

                                 的一道变形题!!!!
状态转移方程 :

pea[i-1][j] = pea[i-1][j] + max ( pea[i][j-1], pea[i][j] , pea[i][j+1] ) ;

下面照例是贴代码 :

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
using std::max;
const int MAX_NUM = 100002;
int pea[MAX_NUM][11];
void setZero ( int t )
{
     for ( int i = 0; i <= t; ++i )
     {
          for ( int j = 0; j != 11; ++ j )
          {
              pea[i][j] = 0;
          }
     }
}
int main ()
{
    int N,temp = MAX_NUM;
    while ( scanf ("%d",&N), N != 0 )
    {
          setZero ( temp );
          int pos,sec;
          int maxSec = 0;
          for ( int i = 0; i != N; ++i )
          {
               scanf ( "%d%d",&pos,&sec ) ;
               pea[sec][pos] ++ ;
               if ( maxSec < sec )
               {
                    maxSec = sec;
               }
          }
          temp = maxSec;
         for ( int i = maxSec; i != 0  ; -- i )
         {
              for ( int j = 0; j != 11; ++ j )
              {
                   if ( j == 0 )
                   {
                        pea[i-1][j] += max ( pea[i][0] , pea[i][1] );
                   }
                   else if ( j == 10 )
                   {
                        pea[i-1][j] += max ( pea[i][9], pea[i][10] );
                   }
                   else
                   {
                        pea[i-1][j] += max ( max ( pea[i][j-1], pea[i][j] ), pea[i][j+1] );
                   }
             }
         }
         printf ( "%d\n",pea[0][5] );
    }
    return 0;
}

MiYu 2010-08-05 14:02 发表评论

HDOJ HDU 2151 Worm ACM 2151 IN HDU

MiYu — Thu, 05 Aug 2010 05:38:00 GMT

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=2151
题目描述:

自从见识了平安夜苹果的涨价后，Lele就在他家门口水平种了一排苹果树，共有N棵。

突然Lele发现在左起第P棵树上(从1开始计数)有一条毛毛虫。为了看到毛毛虫变蝴蝶的过程，Lele在苹果树旁观察了很久。虽然没有看到蝴蝶，但Lele发现了一个规律：每过1分钟，毛毛虫会随机从一棵树爬到相邻的一棵树上。

比如刚开始毛毛虫在第2棵树上，过1分钟后，毛毛虫可能会在第1棵树上或者第3棵树上。如果刚开始时毛毛虫在第1棵树上，过1分钟以后，毛毛虫一定会在第2棵树上。

现在告诉你苹果树的数目N，以及毛毛刚开始所在的位置P，请问，在M分钟后，毛毛虫到达第T棵树，一共有多少种行走方案数。

int a[M][T] ; 表示虫子第 M 分钟时在第T颗树的方法数
状态转移方程为 : a[M][T] = a[M-1][T-1] + a[M-1][T + 1];
代码如下:

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include<iostream>
int main()
{
    int cmt[105][105];
    int N,P,M,T;
    while ( scanf ( "%d%d%d%d",&N,&P,&M,&T ) != EOF )
    {
          memset ( cmt, 0, sizeof ( cmt) );
          cmt[M][T] = 1;
          for ( int i = M - 1; i >= 0; i-- )
          {
                for ( int j = 1;j <= N; j ++ )
                {
                      if ( j - 1 > 0 )
                      {
                           cmt[i][j] += cmt[i+1][j-1];
                      }
                      if ( j + 1 <= N )
                      {
                           cmt[i][j] += cmt[i+1][j+1];
                      }
                }
          }
          printf ( "%d\n",cmt[0][P] );
    }
    return 0;
}

MiYu 2010-08-05 13:38 发表评论

HDOJ HDU 1171 Big Event ACM 1171 IN HDU

MiYu — Thu, 05 Aug 2010 04:44:00 GMT

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址：
http://acm.hdu.edu.cn/showproblem.php?pid=1171

多重背包的题目, 可以直接转换成 0-1背包来做, 因为是要分成尽量相等的2部分, 所以背包大小 sum / 2 就可以了.
另外, 还有一点要注意 , 结束条件是非负数, 而不是 -1 !! 我在这里 TLE了一下午............YM
代码如下 :

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
using namespace std;
int V[51];
int M[51];
int bst[125005];
int main ()
{
    int N;
    while ( scanf ( "%d",&N ), N > 0 )
    {
           int sum = 0;
           for ( int i = 1; i <= N; ++ i )
           {
                 scanf ( "%d%d",&V[i], &M[i] );
                 sum += V[i] * M[i];
           }
           int total = sum;
           sum /= 2;
           memset ( bst, 0 , sizeof ( bst ) );
           for ( int i = 1; i <= N; ++ i )
           {
                 for ( int j = 1; j <= M[i]; ++ j )
                 {
                       for ( int k = sum; k >= V[i] ; k -= V[i] )
                       {
                             if ( bst[ k - V[i] ] + V[i] > bst[k] )
                             {
                                  bst[k] = bst[ k - V[i] ] + V[i] ;
                             }
                       }
                 }
           }
           int other = total - bst[sum];
           if ( other > bst[sum] )
           {
                swap ( other, bst[sum] );
           }
           printf ( "%d %d\n", bst[sum], other );
    }
    return 0;
}

下面的是奋斗哥的代码 ,:

// Author: Tanky Woo
// HDOJ 1171

#include <iostream>
using namespace std;

int c1[250010], c2[250010];
int value[55];
int amount[55];
int main()
{
    int nNum;
    while(scanf("%d", &nNum) && nNum>0)
    {
        memset(value, 0, sizeof(value));
        memset(amount, 0, sizeof(amount));

        int sum = 0;
        for(int i=1; i<=nNum; ++i)
        {
            scanf("%d %d", &value[i], &amount[i]);
            sum += value[i]*amount[i];
        }
        memset(c1, 0, sum*sizeof(c1[0]));
        memset(c2, 0, sum*sizeof(c2[0]));
        for(int i=0; i<=value[1]*amount[1]; i+=value[1])
            c1[i] = 1;
        int len = value[1]*amount[1];
        for(int i=2; i<=nNum; ++i)
        {
            for(int j=0; j<=len; ++j)
                for(int k=0; k<=value[i]*amount[i]; k+=value[i])
                {
                    c2[k+j] += c1[j];
                }
            len += value[i]*amount[i];
            for(int j=0; j<=len; ++j)
            {
                c1[j] = c2[j];
                c2[j] = 0;
            }
        }
        for(int i= sum/2; i>=0; --i)
            if(c1[i] != 0)
            {
                printf("%d %d\n", sum-i, i);
                break;
            }
    }
    return 0;
}

MiYu 2010-08-05 12:44 发表评论