zoukankan      html  css  js  c++  java
  • hdu--1176---dp && 滚动数组优化<porker>

    这题的题意 一定要好好理解----touch   me

    当你在pos处 你下一秒能去的地方就是pos-1 pos pos+1这3个地方 而且如果你在 I 秒的时候 去了pos+1 你就不能捡到 I 秒的时候pos 和 pos-1 处掉下来的馅饼

    清楚了这点 那么样例这个4 就不难得到了

    这题 我想了好久 一开始 sb地想从前往后推状态...

    后来 在纸上模拟下 才试了下 从后往前推

    做完之后 看到hdu这题的discuss里面 有人提到了这就是 数塔 bingo啊... 都没发现 就比往常的数塔 多了一个坐标而已

    这题的for进行状态转移的时候 最好在你输入时间的时候 求出这组数据的最大时间 因为时间最大可以达到100000 要是不求出来 就得从这里开始遍历   太大了。。。

    这里 我们做的时候 把时间都往前进1S 这样可以不用单独地去考虑边界了 那就是用dp[ 0 ] [ 5 ] 来表示答案

    当然 我们也可以还是用 dp [ 1 ][ 5 ]来表示最终答案 就是最后我们要在dp[ 1 ] [ 4 ]  dp[ 1 ] [ 5 ]  dp[ 1 ] [ 6 ]3者之间再进行一次max...因为我们的循环在i = 1处结束了 那么我们对于在time = 1处的选择 还没有进行处理

     1 #include <iostream>
     2 #include <algorithm>
     3 using namespace std;
     4 
     5 const int size = 100010;
     6 int dp[size][15];  // 时间 坐标 
     7 
     8 int main()
     9 {
    10     cin.sync_with_stdio(false);
    11     int n , dir , tim , time_max;
    12     while( cin >> n  && n )
    13     {
    14         time_max = 0;
    15         memset( dp , 0 , (n+10)*11*sizeof(int) );
    16         for( int i = 1 ; i<=n ; i++ )
    17         {
    18             cin >> dir >> tim;
    19             dp[tim][dir] ++;
    20             time_max = max( tim , time_max );
    21         }
    22         for( int i = time_max-1 ; i>=1 ; i-- )
    23         {
    24             dp[i][0] += max( dp[i+1][0] , dp[i+1][1] );
    25             dp[i][10] += max( dp[i+1][10] , dp[i+1][9] );
    26             for( int j = 1 ; j<=9 ; j++ )
    27             {
    28                 dp[i][j] += max( max( dp[i+1][j-1],dp[i+1][j] ) , max( dp[i+1][j],dp[i+1][j+1] ) );
    29                 //cout << i << "  " << j <<"  "<< dp[i][j] << endl;
    30             }
    31         }
    32         dp[1][5] = max( max(dp[1][4],dp[1][5]),max(dp[1][5],dp[1][6]) );
    33         cout << dp[1][5] << endl;
    34     }
    35     return 0;
    36 }
    View Code
     1 #include <iostream>
     2 #include <algorithm>
     3 using namespace std;
     4 
     5 const int size = 100010;
     6 int dp[size][15];  // 时间 坐标
     7 
     8 int main()
     9 {
    10     cin.sync_with_stdio(false);
    11     int n , dir , tim , time_max;
    12     while( cin >> n  && n )
    13     {
    14         time_max = 0;
    15         memset( dp , 0 , sizeof(dp) );
    16         for( int i = 1 ; i<=n ; i++ )
    17         {
    18             cin >> dir >> tim;
    19             dp[tim][dir] ++;
    20             time_max = max( tim , time_max );
    21         }
    22         for( int i = time_max-1 ; i>=0 ; i-- )
    23         {
    24             dp[i][0] += max( dp[i+1][0] , dp[i+1][1] );
    25             dp[i][10] += max( dp[i+1][10] , dp[i+1][9] );
    26             for( int j = 1 ; j<=9 ; j++ )
    27             {
    28                 dp[i][j] += max( max( dp[i+1][j-1],dp[i+1][j] ) , max( dp[i+1][j],dp[i+1][j+1] ) );
    29             }
    30         }
    31         cout << dp[0][5] << endl;
    32     }
    33     return 0;
    34 }
    View Code

    再去撸一把 差不多就快到 2点半了 碎觉,....

    ************************************************

    昨天 就看到有人用1000K的内存 写出了这题 一直想不通怎么做到 虽然想到了滚动数组的优化 但不会实现...

    还好 porker =-=  这个可以帮我好好理解下 滚动 因为dp[i][j] 只与 dp[i+1][j-1 ----> j+1]有关

     1 #include <iostream>
     2 #include <algorithm>
     3 using namespace std;
     4 
     5 const int size = 100010;
     6 int dp[2][15];
     7 
     8 class pie {
     9 public:
    10     int x, t;
    11     bool operator<(const pie& another) const {
    12         return t < another.t;
    13     }
    14 };
    15 
    16 pie p[size];
    17 int pienum;
    18 
    19 int main()
    20 {
    21     cin.sync_with_stdio(false);
    22     int n, dir, tim, time_max;
    23     while (cin >> n  && n)
    24     {
    25         pienum = 0;
    26         time_max = 0;
    27         memset(dp, 0, sizeof(dp));
    28         for (int i = 1; i <= n; i++)
    29         {
    30             cin >> dir >> tim;
    31             p[pienum].x = dir;//坐标
    32             p[pienum++].t = tim;//时间
    33             time_max = max(tim, time_max);
    34         }
    35         sort(p, p + pienum);//按时间排序
    36         for (int i = time_max; i >= 0; i--)
    37         {
    38             int index = i % 2;
    39             int other = 1 - index;
    40             memset( dp[index] , 0 , sizeof(dp[index]) );
    41             while ( pienum > 0 && p[pienum - 1].t == i ) {
    42                 pienum--;
    43                 dp[index] [p[pienum].x ]++;
    44             }
    45             dp[index][0] += max(dp[other][0], dp[other][1]);
    46             dp[index][10] += max(dp[other][10], dp[other][9]);
    47             for (int j = 1; j <= 9; j++)
    48             {
    49                 dp[index][j] += max(max(dp[other][j - 1], dp[other][j]), dp[other][j + 1]);
    50             }
    51         }
    52         cout << dp[0][5] << endl;
    53     }
    54     return 0;
    55 }
    View Code

    这里的关键处理步骤 就是 理解好 index 与 other  和那个 memset( dp[index] , 0 , sizeof(dp[index]) );

    just follow your heart
  • 相关阅读:
    IO编程__字节流__输入
    IO编程__文件夹处理__显示文件夹下所有文件名称
    IO编程__文本文件处理
    IO编程__文件对象
    画坦克__线程__V2__第二种方式调用
    画坦克__线程__V1__第一种方法创造线程
    画坦克__敌人坦克
    画坦克__坦克可移动
    【自动化__GUI自动化】__java__selenium__断言__表格标题内容断言
    选项框
  • 原文地址:https://www.cnblogs.com/radical/p/3883924.html
Copyright © 2011-2022 走看看