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]) );

 

转载于:https://www.cnblogs.com/radical/p/3883924.html

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值