2014 鞍山区域赛 J HDU5079 Square DP套DP

最新推荐文章于 2022-07-19 22:24:57 发布
最新推荐文章于 2022-07-19 22:24:57 发布
阅读量1k 收藏 2
点赞数
分类专栏： 区域赛 文章标签： 区域赛 dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianji_fange_tuhao/article/details/51888835
版权

题意：

给你一个 n⋅n(n≤8) 的棋盘,上面有一些格子必须是黑色,其它可以染黑或者染白,对于一个棋盘,定义它的优美度为它上面最大的连续白色子正方形的边长,对于每个 0≤i≤n ,问有多少种染色方案使得棋盘的优美度为 i ?

说起dp套dp，个人感觉并不是有多么难，关键一个是状态比较难设计

感觉往往内层dp是在给外层处理状态，帮助外层dp把状态压缩好，然后再用一般的dp套dp处理就行了。补了三道这样的题目。


HDU　5079 Square

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include<iostream>
#include <cmath>
#define xx first
#define yy second
#include <algorithm>
#include <map>
using namespace std;
const int N  = 100010;
typedef long long ll;
const ll mod = 1e9+7;
int n;

ll a[10], ans[10], dp[9][1<<12];
char s[10];
ll f2[100];
// dp[i][st]表示搞到了第i行，状态为st
/*
st为一个k进制的数，存的是
这个数字中的第i位表示的是该行从第i个格子到第i+k-1个格子中每个格子往上走的连续白格子个数的最小值j。
这里注意的是，对于size为k的情况，我们只能通过dp维护出最大size<k的情况
然后通过求补求出最大size>=k的情况（因为这些j一旦有>=k的，只能知道他的最大size>=k）
但是却不能维护最大size>k的情况

处理完了这个st，只要枚举下一行的涂法，注意和地图本身一致，去掉错误的染色方法和j>=k的情况即可
个人感觉还可以预处理转移，不过不太会
*/
void init()
{
    f2[0] = 1;
    for( ll i = 1; i <= 65; i ++ ) f2[i] = f2[i-1]*2%mod;;
}


void solve()
{
    scanf("%d", &n);
    int i, k, cnt[10], j, sum = 0;
    memset( ans, 0, sizeof(ans) );
    ans[0] = 1;// all is black
    for( i = 1; i <= n; i ++ ){
        scanf("%s", s);
        a[i] = 0;
        for( j = 0; j < n; j ++ ){
            if( s[j] == '*' )
                a[i] |= ( 1 << j );
            else sum ++;
        }
    }
    ans[1] = ( f2[sum] - 1 + mod ) % mod;
    for( int k = 2; k <= n; k ++ ){
        int sizmax = 1;
        //printf(" size: %d\n", k);
        for( int t = 1; t <= n-k+1; t ++ ) sizmax *= k;
        memset( dp, 0, sizeof(dp) );
        dp[0][0] = 1;
        for( int i = 1; i <= n; i ++ ){
           // printf(" ceng : %d\n", i);
            for( int st = 0; st < sizmax; st ++ ){
              int tmp = st;
              for( int s = 0; s < n-k+1; s ++ ){
                   cnt[s] = tmp%k;
                   tmp /= k;
               }
               for( int ran = 0; ran < ( 1 << n ); ran ++ ){ // 1 is white
                    int fl[10];
                    int sttmp = ( ((1<<n)-1) ^ ran );
                    if( ran & a[i] ) continue;
                    if( ( sttmp & a[i] ) != a[i] ) continue;
                    for( int j = 0; j < n; j ++ ){
                        if( ( ran & ( 1 << j ) ) == 0 ){
                            fl[j] = 1;
                        }// this is black
                        else fl[j] = 0;
                    }
                    int b = 0, f = 0, now[10];
                    for( int p = 0; p < n-k+1; p ++ ){
                        for( j = p; j < p+k; j ++ ){
                            if( fl[j] ){
                                now[p] = 0;
                                break;
                            }
                        }
                        if( j == p+k ) now[p] = cnt[p] + 1;//注意，这里处理新状态一定要新开数组，否则会互相影响
                        if( now[p] >= k ){
                            b = 1;
                            break;
                        }
                    }
                    if( b ) continue;
                    int newst = 0;
                    for( int p = 0, tt = 1; p < n-k+1; p ++, tt *= k ){ // ?
                        newst += now[p]*tt;
                    }
                   // printf("%3d %3d %3d     %3d %3d %3d %3d", st, st%(k), (st/(k))%(k),  ran, ran&1, (ran&2), (ran&4) );
                   // printf("    %3d %3d %3d \n", newst, now[0], now[1] );
                    dp[i][newst] += dp[i-1][st];
                    dp[i][newst] %= mod;
                }
            }
            //for( int st = 0; st < sizmax; st ++ ){ printf("dp %d  %d\n", st, dp[i][st]); }
        }
        for( int i = 0; i < sizmax; i ++ ){
            ans[k] += dp[n][i];
            ans[k] %= mod;
        }
        ans[k] = ( f2[sum] - ans[k] + mod ) % mod;
    }
    for( int i = 1; i <= n-1; i ++ ){
            ans[i] = ( ans[i] - ans[i+1] + mod ) %mod;
    }
    for( i = 0; i <= n; i ++ )printf("%lld\n", ans[i]%mod);
}

int main()
{
    int T;
   // freopen("in.txt", "r", stdin);
    cin >> T;
    init();
    while( T -- ){
        solve();
    }
}


还补了两道 HDU 4899  最大公共子序列的


#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<vector>
#include<queue>
#include<map>
#define lson l, mid, x<<1
#define rson mid+1, r, x<<1|1
#define xx first
#define yy second
#define N 200000
using namespace std;
typedef __int64 ll;
const ll INF = 99999999999999999;
const ll mod = 1e9+7;

char s[20], num[4] = { 'A', 'C', 'G', 'T' };
int m, n;
ll f[2][(1<<15)+5];
int trans[(1<<15)+5][4];
ll ans[20];

void solve()
{
    int i, j;
    n = strlen(s);
    int st = 0;
    int dp[20], ndp[20];
    for( st = 0; st < ( 1 << n ); st ++ ){
        i = 1; dp[0] = 0;
        memset( dp, 0, sizeof(dp) );
        memset( ndp, 0, sizeof(ndp) );
        for( i = 1; i <= n; i ++ ){
            dp[i] = dp[i-1] + ( ( st >> (i-1) ) & 1 );
        }
        ndp[0] = 0;
        for( j = 0; j < 4; j ++ ){
            for( i = 0; i < n; i ++ ){
                if( num[j] == s[i] ){
                    ndp[i+1] = dp[i] + 1;
                }
                else ndp[i+1] = max( ndp[i], dp[i+1] );
            }
            int newst = 0;
            for( i = 1; i <= n; i ++ ){
                newst |= ( ( ndp[i] != ndp[i-1] ) << (i-1) );
            }
            trans[st][j] = newst;
        }
    }
    memset( f, 0, sizeof(f) );
    f[0][0] = 1;
    for( i = 0; i < m; i ++ ){
        memset( f[(i&1)^1], 0, sizeof(f[(i&1)^1]) );
        for( st = 0; st < ( 1 << n ); st ++ ){
            for( j = 0; j < 4; j ++ ){
                f[(i&1)^1][trans[st][j]] += f[i&1][st];
                if( f[(i&1)^1][trans[st][j]] >= mod ) f[(i&1)^1][trans[st][j]] -= mod;
            }
        }
    }
    memset( ans, 0, sizeof(ans) );
    for( st = 0; st < ( 1 << n ); st ++ ){
        int cnt = 0;
        int tmp = st;
        while( st ){
            cnt += ( st & 1 );
            st >>= 1;
        }
        st = tmp;
        ans[cnt] += f[m&1][st];
        if( ans[cnt] >= mod ) ans[cnt] -= mod;
    }
    for( i = 0; i <= n; i ++ )printf("%I64d\n", ans[i]);
}

int main()
{
    int T;
    //freopen("in.txt", "r", stdin );
    //freopen("out.txt", "w", stdout );
    cin >> T;
    while( T -- ){
        scanf("%s%d", s, &m);
        solve();
    }
}
/*
观察到十分重要的一点 S和T的最长公共子序列，最大为lens
那么，我们想要得出内部的dp，即S每一位的增长状态（+1or no）
然后枚举添四个字母中的一个，来转移状态
预处理后，最后解决问题
*/


HDU 5548 南阳 麻将

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef long long ll;
int m;
const int mod = 1e9+7;
ll g[260][5];//g[id][l],id这个状态下取l个将会转化成什么样的状态
int dp[205][205][260];
bool can[260];

ll make_st( int op, int a, int b )
{
    return op*25 + a*5 + b;
}

ll extend( int op, int a, int b, int j )
{
    ll s = 0;
    if( a == 0 ){
        s |= 1LL << make_st( op, b, j );
        if( j >= 3 ) s |= 1LL << make_st( op, b, j-3 );
        if( j >= 2 &&!op ) s |= 1LL << make_st( 1, b, j-2 );
    }
    if( a >= 1 && a <= min( b, j ) ){
        s |= 1LL << make_st( op, b-a, j-a );
        if( !op && j-a >= 2 ) s |= 1LL << make_st( 1, b-a, j-a-2 );
        if( j-a >= 3 ) s |= 1LL << make_st( op, b-a, j-a-3 );
    }
    return s;
}
//i-2剩下a张，i-1剩下b张，第i种牌选了j张，必须把a处理掉，否则以后就没有机会了
//没必要处理b，因为选b的时候一定会先处理的

void bfs()
{
    queue<ll>q;
    map<ll,int>mp;
    m = 0;
    q.push(1);
    mp[1] = ++m;
    while(!q.empty()){
        ll tmp = q.front(); q.pop();
        for( int j = 0; j <= 4; j ++ ){
            ll s = 0;
            for( int i = 0; i < 50; i ++ ){
                if( (1LL<<i) & tmp ){
                    s |= (ll)extend( i/25, (i%25)/5, i%5, j );//搞清楚每个变量分别代表什么,s代表的是状态的集合
                }//i是单纯的状态扩展
            }
            if( !mp[s] ){
                mp[s] = ++m;
                if( (1LL<<25) & s )can[m] = 1;
                q.push(s);
            }
            g[mp[tmp]][j] = mp[s];
        }
    }
//    for( int i = 1; i <= m; i ++ ){
//        printf("g %d : ", i);
//        for( int j = 0; j < 5; j ++ ){
//            printf("%3d ", g[i][j]);
//        }
//        printf("\n");
//    }
}
// 用bfs扩展出所有的状态，一共251个 = = 不过并不知道为什么只有这么一点
void solve()
{
    dp[0][0][1] = 1;
    for( int i = 0; i <= 200; i ++ ){
        for( int j = 0; j <= 200; j ++ ){
            for( int k = 1; k <= m; k ++ ){
                if( dp[i][j][k] ){
                    for( int l = 0; l <= 4; l ++ ){
                        dp[i+1][j+l][g[k][l]] = ( dp[i+1][j+l][g[k][l]] + dp[i][j][k] ) % mod;
                    }
                }
            }
        }
    }
}
int main()
{
    bfs();
    solve();
    //cout << m << endl;
    int T, cas = 1;
    cin >> T;
    int p, q;
    while( T -- ){
        scanf("%d %d", &p, &q);
        ll ans = 0;
        for( int i = 1; i <= m; i ++ ){
            if( can[i] ){
                ans += dp[p][q][i];
                ans %= mod;
            }
        }
        printf("Case #%d: %I64d\n", cas++, ans);
    }
}
最后给个信息： http://wjmzbmr.com/archives/my-favorite-problems-in-2014/

tianji_fange_tuhao
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dp套dp（动态规划）
xajd1906的博客
01-25 1474
dp套dp 这是一个对于一类动态规划的计数问题的处理方法，问题常常是如果形式确定就可以直接dp，但是现在却要求满足某个要求的所有方案数，一般的处理方法就是一维负责增量构造，其他维度用来表示内部dp状态，然后转移时候先让内部状态转移，然后外部dp对应存储方案数。 类似于将内部的dp转移变成一个自动机，可以接受所有不同的转移，然后我们的外层dp就是在自动机上进行计数。 P4590 [TJOI2018]游园会 给定一个长度为k的字符串，求解长度为n的字符串中LCS为i的个数，对所有的i输出答案。 首先对于LCS的
[XSY] 相似（DP套DP）
Edward The Bunny 的博客
03-04 267
在看这道题前，有必要先看一下DP套DP的入门题[uoj3864]Hero meet devil，附上两篇写得不错的题解： https://blog.csdn.net/Ike940067893/article/details/87863041 https://www.cnblogs.com/RabbitHu/p/BZOJ3864.html 设阀值为mmm 设 lcsi,jlcs_{i,j}lcsi,j​ 表示 S[1...i]S[1...i]S[1...i] 与 T[1...j]T[1...j]T[1...j
DP 套 DP
EricQian的博客
04-25 286
DP 套 DP 学习笔记 大致内容 DP 套 DP 就是将一个简单 DP 的状态压缩起来放到新的 DP 中当做状态进行 DP 的过程。 常用于计算简单 DP 的答案为 \(k\) 的转移方案的数量。 一般都需要 decode 和 recode 操作，这里和 插头DP/轮廓线DP 有异曲同工之妙！ 例题 P4590 [TJOI2018]游园会 按照以前的套路来，设 \(dp(i,j,p)\) 表示...
【2022国赛模拟】相似序列问题——DFA（DP套DP）
偶耶的博客
07-19 362
鸽了一周没写博客了
hdu5079
weixin_34080951的博客
02-08 227
这道题的难点在于思考dp表示什么 首先可以令ans[len]表示白色子矩阵边长最大值大于等于len的方案数则ans[len]-ans[len+1]就是beautifulness为len的方案数 白色子矩阵边长最大值大于等于len的方案数=总方案-白色子矩阵边长最大值小于len的方案数 经过这样的转化，我们就好dp了，我们先穷举len 令f[i][st]表示到第i行，状态为st的白色子矩阵边...
DP套DP
weixin_30500105的博客
09-29 187
DP套DP，就是将内层DP的结果作为外层DP的状态进行DP的方法。 [BZOJ3864]Hero meet devil 对做LCS的DP数组差分后状压，预处理出转移数组，然后直接转移即可。 tr[S][k]表示当前差分状压后的状态为S，加入字符k(k为ACGT中一个)后会转移到什么状态。 f[i][S]表示串已构造到第i位，和模式串的匹配状态差分后为S，的方案数。 1 #in...
DP.rar_DP_hdu_动态规划_动态规划 C++
09-20
动态规划DP题解 POJ HDU部分动态规划DP题解
HDU DP 题集
04-24
动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，...
HDU DP题解
02-07
HDU上DP大集合，里面包括题，题解，代码，对DP入门者很实用，对DP老手也是有很大的提高
HDU DP动态规划
03-31
HDU的一题．.......HDU DP动态规
初探数位dp.pdf
09-16
lazycal的集训队报告：初探数位DP 以HDU 2089，HDU 3652, URAL 1057等题目为例，介绍了数位DP的算法
hdu 5079 Square
weixin_34417200的博客
02-20 128
http://acm.hdu.edu.cn/showproblem.php?pid=5079 题意： n*n网格，每个格子可以涂黑色或白色，有的格子必须涂黑色 问最大白色正方形边长分别为0,1,2，……n 的涂色方案数 令ans[i]表示最大白色正方形边长小于i的方案数 最大边长=i 的就是ans[i+1]-ans[i] 枚举sz，表示现在要求最大白色正方形边长<i的...
[DP套DP] UOJ#141. 【UER #4】量子态的棋盘
Lynstery's blog
06-29 666
题意 n,m<=10 K<=1e+18题解这个小球数很大，但是注意到如果落在某个网格的小球数为偶数，必然是一半往上一半往下，与格子权值无关，只有当小球数为奇数的时候，最后一个小球的走向才和格子权值有关。 所以我们先推一趟，把不确定走向的小球留在那个位置。这样最多就只有n*m个球了。 然后考虑轮廓线DP，记下这里有几个小球从这个边界位置滚下。 这个状态数的数量比较玄学，反正就是能过的。 如何
dp套dp
HaoGe17的博客
03-16 291
听起来很高级。 考虑普通的dp 常常是fif_{i}fi​从fi−1f_{i-1}fi−1​通过转移T来的这样的形式。 下标之间的转移很方便。 有事fif_{i}fi​的这个iii想知道从哪里转移过来不像上面那么容易。 需要把iii视作另一个dp中某个状态的值。而它在另一个dp中又一个值为j的状态通过T转移而来。 此时就在外层dp中让fif_{i}fi​从fjf_{j}fj​转移过来。 而内层循环尝尝不是临时计算，而是提前计算好对于任意一个i，面对转移T会转移到谁。那么可以提前构造好一个自动机。 外层dp此
【dp水题】HDU5079+LGP2051
MEET YOU FIRST TIME
12-04 416
dp水题
省选＋NOI 第一部分 动态规划DP
青少年趣味编程
03-16 490
期望概率DP 【整理】简单的数学期望和概率DP 【整理】简单的数学期望和概率DP - nimphy - 博客园 期望&概率dp总结 期望&amp;概率dp总结_十分残念的博客-CSDN博客 期望&amp;概率dp总结_十分残念的博客-CSDN博客 概率dp+期望dp 题目列表（一） 概率dp+期望dp 题目列表（一） - 知る奇迹に - 博客园 概率DP/期望DP http://www.cyzuo.cn/index.php/archives/63/..
[DP套DP] HDU5079: Square
Lynstery's blog
06-28 824
题意给出一个n*n的网格，每个格子一开始都是黑的，且有些格子是损坏的。 现在可以任意选择一些非损坏格子染成白色。定义一个染色方案的优美度为白色最大子正方形的边长。 对于每个i=0~n，求优美度恰为i的染色方案。 n<=10题解显然是DP套DP。 首先思考最大子正方形这个全局的东西比较难用一个较简单的状态直接体现出来。 所以就分开来做，考虑容斥，如果我们求出了ans[i]表示最大子正方形边长
[DP套DP] UOJ #141 【UER #4】量子态的棋盘
雯舞
05-31 965
预先DP一遍则每个格子最多留一个球，然后对轮廓线的状态装压 如果定义一个点的状态数不超过SS 那么据题解说SS大概是5×1055\times 10^5 复杂度O(nmS)O(nmS) 接下来是卡常时刻 我先是把轮廓线上的球数转化成一个80进制数 然后和当前已经入袋的球数hash在一起 hashmap里面存一下 成功rnk1 开心#include<cstdio> #include<cstdl
CodeForces - 137D Palindromes(dp+路径输出)
Falcon的博客
12-04 377
题目链接：点击查看 题目大意：给出一个长度为 n 的回文串，问最小修改多少个字母，可以使得整个回文串可以被划分成不超过 k 个连续的回文串，并输出最终的划分方案 题目分析：n 和小，考虑多维 dp 首先预处理出 cost 函数辅助 dp 的转移，cost[ l ][ r ] 是将区间 [ l , r ] 内的字符串修改成回文串的最小花费，转移方程也比较简单 cost[ l ][ r ] = cost[ l + 1 ][ r - 1 ] + ( a[ l ] != a[ r ] )，时间复杂度是 O(
hdu 2829 lawrence 斜率优化dp
最新发布
06-28
hdu 2829 Lawrence 斜率优化dp 这道题是一道经典的斜率优化dp题目，需要用到单调队列的思想。 题目大意是给定一个序列a，求出一个序列b，使得b[i]表示a[1]~a[i]中的最小值，且满足b[i] = min{b[j] + (i-j)*k}，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值