POJ 1661 帮助Jimmy 解题报告

POJ 1661 帮助Jimmy 解题报告

编号：1661

 

考查点：动态规划

 

思路：依然寻找状态转移，两种选择，向左走or向右走。所以就是到下一块之间的高度加上下一块左右两种情况的最小的一种情况.。这个我基本都想到了，先排序这个我也想到了，但是在思路基本正确的情况下，由于方法太繁琐（我写了两个函数递归，SearchgLeft和SearchRight），最终结果是从昨天晚上debug到今天晚上，终于今天看书后，修改递归函数，又因为那个bool值问题debug了俩小时.在即将发邮件给别人求助前一刻发现了bug..Thank Goodness

 

提交情况: 无数次的失败后，终于做出来了，主要WA原因是前期方法太繁琐和后来没弄明白bool值对应的是左还是右.。

 

Source Code：

 

// POJ Grids 1661
#include  < iostream >
using   namespace  std;

struct  PlatForm{
     int  x;
     int  y;
     int  h;
};
struct  MinTime{
     int  left;
     int  right;
};

int  x,y,count,maxTime;
PlatForm platform[ 2024 ];
MinTime mintime[ 2024 ];


int  Compare( const   void *  e1, const   void *  e2)
{
     return  ((PlatForm * )e2) -> h  -  ((PlatForm * )e1) -> h; 
}

int  Search( int  n, bool  flag)
{
     int  h  =  platform[n].h;
     int  x  =   0 ;
     if  (flag)
        x  =  platform[n].x;
     else
        x  =  platform[n].y;
     int  i = n + 1 ;
     for  (;i <= count;i ++ )
    {
         if  (x >= platform[i].x  &&  x <= platform[i].y)
        {
             if  (h - platform[i].h > maxTime)
                 return   3000000 ;
             break ;
        }
    }
     if  (i > count)
    {
         if  (h > maxTime)
             return   3000000 ;
         return  h;
    }
     int  left  =  h - platform[i].h + x - platform[i].x;
     int  right  =  h - platform[i].h + platform[i].y - x;

     if  ( ! mintime[i].left)
        mintime[i].left  =  Search(i, true );
     if  ( ! mintime[i].right)
        mintime[i].right  =  Search(i, false );

    left  +=  mintime[i].left;
    right  +=  mintime[i].right;

     return  left < right  ?  left : right;
}

int  main()
{
     int  t;cin >> t;
     while  (t -- )
    {
        memset(platform, 0 , sizeof  platform);
        memset(mintime, 0 , sizeof  mintime);

        cin >> count >> x >> y >> maxTime;

        platform[ 0 ].x  =  x;
        platform[ 0 ].y  =  x;
        platform[ 0 ].h  =  y;
         for  ( int  i = 1 ;i <= count;i ++ )
        {
            cin >> platform[i].x;
            cin >> platform[i].y;
            cin >> platform[i].h;
        }

        qsort(platform,count + 1 , sizeof (PlatForm),Compare);

         int  min  =  Search( 0 , false );

        cout << min << endl;
    }

     return   0 ;
}

总结：泛型函数的思想在ACM里也能体会的到，如果发现两个函数的功能相当类似，就把其中不同的抽象成参数，构造一个泛型函数.。还有，坚持就是胜利！

 

 

 

                                                       By   Ns517

                                                      Time 09.02.09

转载于:https://www.cnblogs.com/ns517/archive/2009/02/09/1387122.html