HDU 3341 Lost's revenge（AC自动机+DP+变进制优化）

最新推荐文章于 2020-08-17 19:04:32 发布
最新推荐文章于 2020-08-17 19:04:32 发布
阅读量628 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 动态规划 字符串—ac自动机 数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Ezereal/article/details/52179986
本文介绍了一种针对DNA序列重新排列的问题，通过优化算法确保排列中包含尽可能多的数论基因。利用压缩状态的方法减少内存消耗，并采用动态规划实现高效求解。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题目是给一个DNA重新排列使其包含最多的数论基因。

字符最长是40
只需要记录ACGT出现的次数。
如果使用5维数组，显然超内存了。
假设ACGT的总数分别为num[0],num[1],num[2],num[3]
那么对于ACGT的数量分别为ABCD的状态可以记录为：
A*(num[1]+1)*(num[2]+1)*(num[3]+1) + B*(num[2]+1)*(num[3]+1)+ C*(num[3]+1) +D
这样的状态最大就是11*11*11*11
复杂度也可以承受了。
字符串可能有重复的，用int来记录数量

忘了dp【j】【i】小于0直接continue的情况，wa了好多。。
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define L(i) i<<1
#define R(i) i<<1|1
#define INF  0x3f3f3f3f
#define pi acos(-1.0)
#define eps 1e-9
#define maxn 60010
#define MOD 1000000007

int n,m;
int dp[510][20010];
int bit[13],num[13];
struct Trie
{
    int next[510][5],fail[510],en[510];
    int root,L;
    void init()
    {
        L = 0;
        root = newnode();
    }
    int newnode()
    {
        for(int i = 0; i < 4; i++)
            next[L][i] = -1;
        en[L++] = 0;
        return L-1;
    }
    int getch(char ch)
    {
        if(ch == 'A')
            return 0;
        else if(ch == 'C')
            return 1;
        else if(ch == 'G')
            return 2;
        return 3;
    }
    void Insert(char buf[])
    {
        int now = root;
        int len = strlen(buf);
        for(int i = 0; i < len; i++)
        {
            if(next[now][getch(buf[i])] == -1)
                next[now][getch(buf[i])] = newnode();
            now = next[now][getch(buf[i])];
        }
        en[now]++;
    }
    void build()
    {
        queue<int> Q;
        fail[root] = root;
        for(int i = 0; i < 4; i++)
        {
            if(next[root][i] == -1)
                next[root][i] = root;
            else
            {
                fail[next[root][i]] = root;
                Q.push(next[root][i]);
            }
        }
        while(!Q.empty())
        {
            int now = Q.front();
            Q.pop();
            en[now] += en[fail[now]];
            for(int i = 0; i < 4; i++)
            {
                if(next[now][i] == -1)
                    next[now][i] = next[fail[now]][i];
                else
                {
                    fail[next[now][i]] = next[fail[now]][i];
                    Q.push(next[now][i]);
                }
            }
        }
    }
    int ok(int x,int &a,int &b,int &c,int &d)
    {
        a = x/bit[0];
        if(a > num[0])
            return 0;
        x -= a*bit[0];
        b = x/bit[1];
        if(b > num[1])
            return 0;
        x -= b*bit[1];
        c = x/bit[2];
        if(c > num[2])
            return 0;
        x -= c*bit[2];
        d = x/bit[3];
        if(d > num[3] || x-d*bit[3] != 0)
            return 0;

        return 1;
    }
    int solve()
    {
        char s[1010];
        scanf("%s",s);
        int len = strlen(s);
        memset(num,0,sizeof(num));
        for(int i = 0; i < len; i++)
            num[getch(s[i])]++;
        bit[0] = (num[1]+1)*(num[2]+1)*(num[3]+1);
        bit[1] = (num[2]+1)*(num[3]+1);
        bit[2] = num[3]+1;
        bit[3] = 1;
        int ss = num[0]*bit[0] + num[1]*bit[1] + num[2]*bit[2] + num[3]*bit[3];
        memset(dp,-1,sizeof(dp));
        dp[root][0] = 0;
        for(int i = 0; i <= ss; i++)
        {
            int a,b,c,d;
            if(ok(i,a,b,c,d))
                for(int j = 0; j < L; j++)
                {
                    if(dp[j][i] < 0)
                        continue;
                    if(a < num[0])
                        dp[next[j][0]][i+bit[0]] = max(dp[next[j][0]][i+bit[0]],dp[j][i]+en[next[j][0]]);
                    if(b < num[1])
                        dp[next[j][1]][i+bit[1]] = max(dp[next[j][1]][i+bit[1]],dp[j][i]+en[next[j][1]]);
                    if(c < num[2])
                        dp[next[j][2]][i+bit[2]] = max(dp[next[j][2]][i+bit[2]],dp[j][i]+en[next[j][2]]);
                    if(d < num[3])
                        dp[next[j][3]][i+bit[3]] = max(dp[next[j][3]][i+bit[3]],dp[j][i]+en[next[j][3]]);
                }
        }
        int ans = 0;
        for(int i = 0; i < L; i++)
            ans = max(ans,dp[i][ss]);
        return ans;
    }
} ac;
int main()
{
    int t,C = 1;
    //scanf("%d",&t);
    while(scanf("%d",&n) && n)
    {
        ac.init();
        char s[1010];
        for(int i = 0; i < n; i++)
        {
            scanf("%s",s);
            ac.Insert(s);
        }
        ac.build();
        printf("Case %d: %d\n",C++,ac.solve());
    }
    return 0;
}

大牛代码：
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define L(i) i<<1
#define R(i) i<<1|1
#define INF  0x3f3f3f3f
#define pi acos(-1.0)
#define eps 1e-9
#define maxn 60010
#define MOD 1000000007

int n,m;
int dp[510][20010];
int bit[13],num[13];
struct Trie
{
    int next[510][5],fail[510],en[510];
    int root,L;
    void init()
    {
        L = 0;
        root = newnode();
    }
    int newnode()
    {
        for(int i = 0; i < 4; i++)
            next[L][i] = -1;
        en[L++] = 0;
        return L-1;
    }
    int getch(char ch)
    {
        if(ch == 'A')
            return 0;
        else if(ch == 'C')
            return 1;
        else if(ch == 'G')
            return 2;
        return 3;
    }
    void Insert(char buf[])
    {
        int now = root;
        int len = strlen(buf);
        for(int i = 0; i < len; i++)
        {
            if(next[now][getch(buf[i])] == -1)
                next[now][getch(buf[i])] = newnode();
            now = next[now][getch(buf[i])];
        }
        en[now]++;
    }
    void build()
    {
        queue<int> Q;
        fail[root] = root;
        for(int i = 0; i < 4; i++)
        {
            if(next[root][i] == -1)
                next[root][i] = root;
            else
            {
                fail[next[root][i]] = root;
                Q.push(next[root][i]);
            }
        }
        while(!Q.empty())
        {
            int now = Q.front();
            Q.pop();
            en[now] += en[fail[now]];
            for(int i = 0; i < 4; i++)
            {
                if(next[now][i] == -1)
                    next[now][i] = next[fail[now]][i];
                else
                {
                    fail[next[now][i]] = next[fail[now]][i];
                    Q.push(next[now][i]);
                }
            }
        }
    }
    int solve()
    {
        char s[1010];
        scanf("%s",s);
        int len = strlen(s);
        memset(num,0,sizeof(num));
        for(int i = 0; i < len; i++)
            num[getch(s[i])]++;
        bit[0] = (num[1]+1)*(num[2]+1)*(num[3]+1);
        bit[1] = (num[2]+1)*(num[3]+1);
        bit[2] = num[3]+1;
        bit[3] = 1;
        memset(dp,-1,sizeof(dp));
        dp[root][0] = 0;
        for(int A = 0; A <= num[0]; A++)
            for(int B = 0; B <= num[1]; B++)
                for(int C = 0; C <= num[2]; C++)
                    for(int D = 0; D <= num[3]; D++)
                    {
                        int s = A*bit[0] + B*bit[1] + C*bit[2] + D*bit[3];
                        for(int i = 0; i < L; i++)
                            if(dp[i][s] >= 0)
                            {
                                for(int k = 0; k < 4; k++)
                                {
                                    if(k == 0 && A == num[0])
                                        continue;
                                    if(k == 1 && B == num[1])
                                        continue;
                                    if(k == 2 && C == num[2])
                                        continue;
                                    if(k == 3 && D == num[3])
                                        continue;
                                    dp[next[i][k]][s+bit[k]] = max(dp[next[i][k]][s+bit[k]],dp[i][s]+en[next[i][k]]);
                                }
                            }
                    }
        int ans = 0;
        int ss = num[0]*bit[0] + num[1]*bit[1] + num[2]*bit[2] + num[3]*bit[3];
        for(int i = 0; i < L; i++)
            ans = max(ans,dp[i][ss]);
        return ans;
    }
} ac;
int main()
{
    int t,C = 1;
    //scanf("%d",&t);
    while(scanf("%d",&n) && n)
    {
        ac.init();
        char s[1010];
        for(int i = 0; i < n; i++)
        {
            scanf("%s",s);
            ac.Insert(s);
        }
        ac.build();
        printf("Case %d: %d\n",C++,ac.solve());
    }
    return 0;
}


小明系列故事——女友的考验 HDU - 4511 （AC自动机+dp）
Top_Spirit的博客
07-17 508
　终于放寒假了，小明要和女朋友一起去看电影。这天，女朋友想给小明一个考验，在小明正准备出发的时候，女朋友告诉他，她在电影院等他，小明过来的路线必须满足给定的规则： 　　1、假设小明在的位置是1号点，女朋友在的位置是n号点，则他们之间有n-2个点可以走，小明每次走的时候只能走到比当前所在点编号大的位置； 　　2、小明来的时候不能按一定的顺序经过某些地方。比如，如果女朋友告诉小明不能经过1 -&gt...
HDU 4878 ZCC loves words（AC自动机 + dp + 矩阵快速幂 + 中国剩余定理）
alpc_qleonardo
02-18 404
    大致题意：给你一些匹配串和一个很长的长度L。让你计算所有长度为L的小写字母构成的字符串的得分总和对5047621取模后的数值。这里，每个字符串s的得分定义为，若s的子串s[i..j]等于第k个匹配串，那么产生p[k]*(len[k]+j)的得分，最后的得分为每一次得分的积。 由于涉及到匹配的问题，所以很自然的可以想到用上AC自动机。我们考虑AC自动机上的dp，我们令dp[l]...
HDU3341--Lost's revenge
SCUT_Pein
09-19 1006
Problem Description Lost and AekdyCoin are friends. They always play "number game"(A boring game based on number theory) together. We all know that AekdyCoin is the man called "nuclear weapon of FZ
HDU - 3341 Lost's revenge(AC自动机+DP)
那些年
10-17 1562
Description Lost and AekdyCoin are friends. They always play "number game"(A boring game based on number theory) together. We all know that AekdyCoin is the man called "nuclear weapon of FZU,descen
HDU 3341-Lost's revenge（AC自动机+DP+hash）
信仰.的博客
08-11 627
Lost's revenge Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others) Total Submission(s): 4317    Accepted Submission(s): 1199 Problem Description Lost and Aekdy
hdoj 3341 Lost's revenge 【AC自动机 + 变进制状态压缩dp】
世界很大
10-18 684
Lost's revenge Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others) Total Submission(s): 3452    Accepted Submission(s): 932 Problem Description Lost and Ae
HDU2243 考研路茫茫——单词情结 AC自动机DP矩阵优化
上决╇ф的ACM
01-29 1674
传送门：点击打开链接 考研路茫茫——单词情结 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 3929    Accepted Submission(s): 1147 Problem Description 背单词，
HDU 3341 Lost's revenge AC自动机 + 变进制状压DP
Gatevin的专栏
11-23 782
题目大意： 现在给出一个DNA序列
HDU 3341 Lost's revenge AC自动机+dp
diaocuiguo2493的博客
04-30 143
Lost's revenge Time Limit: 15000/5000 MS (Java/Others)Memory Limit: 65535/65535 K (Java/Others)Total Submission(s): 3757Accepted Submission(s): 1020 Problem Description Lost and AekdyC...
hdu 3341(ac自动机+状态压缩)
10-29
hdu 3341(ac自动机+状态压缩) 题意：容易理解... 思路：首先一开始容易想到要用到dp，开设一个dp[41][41][41][41][501]的数组来解决，但是明显内存已经超出范围了，于是就想如何减少内存呢？只要知道A、T、C、G其中...
HDU 6791 Border 理论 + 回文自动机 + 树上倍增 + 双哈希
weixin_43485513的博客
08-17 359
       题目给定一个字符串，两个人都会选取其中一个回文串。接下来，构造一个新串，持续的添加字母，每个字母有等同的概率出现，问你谁选取的字符串最大可能最先出现。        介绍一下 BorderBorderBorder 理论。对于一个长度为 LLL 的序列 AAA，若 A[1, i]=A[L−i+1, L]A[1,\ i] = A[L - i
【二进制分组+AC自动机】HDU4787[GRE Words Revenge]题解
ZigZagK的博客
12-23 511
题目概述给出 nn 个操作，操作有两种：1.加入一个 0101 串。2.询问一个 0101 串中子串是学过单词的个数。强制在线。解题报告如果是插入完再询问，就是AC自动机裸题。如果不强制在线，可以按照时间分治。然而都不满足啊，只能另想办法了。又一个神奇的暴力，二进制分组就派上用场了。每次插入都必须重建AC自动机，但是这是无法承受的。我们将插入分组，如果这一组与上一组的个数相同，那么就将两者合并，并重
hdu 3962(AC自动机+矩阵优化dp)
hexianhao的博客
03-07 777
转载标记处：http://blog.youkuaiyun.com/woshi250hua/article/details/7599472 题目大意：给定m个DNA病毒序列，求碱基构成的长度为n且含有两个以上DNA病毒序列,结果对10007取模。 解题思路：本题代码量大，较为综合，需用到AC自动机改造而成的Trie图、DP思想、矩阵快速幂。      如果n比较小，那么
AC自动机+DP小结 （一）
ddyyxx的程序员之路
11-13 5661
好久没有更新博客了，最近真是懒到家了，南京赛前重点复习了下AC自动机+DP方面的题，写下来总结一下。 HDU 2457  DNA repair http://acm.hdu.edu.cn/showproblem.php?pid=2457 题意：
2016"百度之星" - 初赛（Astar Round2A）Sitting in Line(★)
Ezereal的博客
05-21 1268
度度熊是他同时代中最伟大的数学家，一切数字都要听命于他。现在，又到了度度熊和他的数字仆人们玩排排坐游戏的时候了。游戏的规则十分简单，参与游戏的N个整数将会做成一排，他们将通过不断交换自己的位置，最终达到所有相邻两数乘积的和最大的目的，参与游戏的数字有整数也有负数。度度熊为了在他的数字仆人面前展现他的权威，他规定某些数字只能在坐固定的位置上，没有被度度熊限制的数字则可以自由地交换位置。  
codeforces 118D Caesar's Legions (好题)
Ezereal的博客
03-27 1190
题意：  有n1个骑兵，n2个步兵，排成一列。  求满足下列条件的排列数。  1）连续的骑兵不超过k1  2）连续的步兵不超过k2  思路：  使用状态dp【i】【j】【k】，i，j：步兵，骑兵个数  k：0是步兵，1是骑兵 状态方程：for(int k = 1; k                 dp[i][j][0] = (dp[i][j][0] + dp[i-k][j
codeforces 713C(Round #371 Div2 E) Sonya and Problem Wihtout a Legend ★ ★
Ezereal的博客
10-15 805
题目描述：给出一个包含n个数的序列a1,a2,...,an，先要把该序列修改成严格单增的序列，假设修改成 b1,b2,...,bn的花费为 |a1 - b1|+|a2 - b2|+...+|an - bn|，问最小花费是多少？ 方法：非常类似于POJ3666，建议先把这道题AC，为了转化成POJ3666，需对性质进行如下分析： 严格递增的含义是a[j] - a[i] >= j -
POJ 1742 Coins （多重背包）
Ezereal的博客
08-22 771
题意：有n种面额的硬币，面额个数分别为A_i、C_i，求最多能搭配出几种不超过m的金额？ 题解：看了别人代码敲完 #include #include #include #include #include #include #include #include #include #include #include #define INF 0x3f3f3f3f #define maxn
hdu 5823 color II（状态压缩DP） ★
Ezereal的博客
08-12 705
题意：给你一个图G，求每个子图的最少染色数 思路：每个子图的染色问题，可以看成是找每个子图的独立集问题（两两顶点互不相邻的图叫独立集），可以先枚举每个状态，然后枚举每个顶点，表示以这个顶点为起始的子图，再枚举每个顶点，表示这个顶点和上面那个顶点所构成的图是一个独立集，预处理出所有非法的状态，即他们之间有边。            令dp[s]为子图S已经染色的最少染色数，那么有dp[s]=mi
HDU 300+AC代码解析：大数、线段树、字符串与动态规划
1. HDU (Humanitarian Digital University)：首先需要了解的是HDU并非常规意义上的大学，而是指的是一个在线编程练习平台，类似于LeetCode、Codeforces等，它常被用于算法与数据结构的练习和竞赛。其提供的题目难度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值