每日总结-05-19（AC自己主动机结束）

最新推荐文章于 2022-11-12 19:05:43 发布
最新推荐文章于 2022-11-12 19:05:43 发布
阅读量68 收藏
点赞数

今天下午讨论了一下校赛的题，最终最终拍板，把校赛的题目定下来了。

然后今天A掉了4个AC自己主动机的题目。最终完毕了AC自己主动机专辑里面的15个题。至此AC自己主动机全然结束。

明天开启线段树专题。

。。。。

------------------------------------------------------------------------------------------------------------------------------------

1,，hdu-2457-DNA repair

题目：给出一些不合法的模式DNA串，给出一个原串，问最少须要改动多少个字符，使得原串中不包括非法串

做法：把病毒串做成一个trie树。

DP[i][j]:长度为i，在trie树上的状态为j。须要改变的最少的字符的个数。

dp[i][j]=dp[i-1][k]+转移费用。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<string.h>
#include<math.h>
using namespace std;
#define LL __int64
#define maxn 55
const int maxnode=55*21;
const int childnum=5;
const int mod=1000000007;
const int INF=99999999;
struct ac_tree
{
    int chd[maxnode][childnum];
    int val[maxnode];
    int fail[maxnode];
    int key[1<<11];
    int Q[maxnode];
    int ID[128];
    int sz;
    int dp[1100][maxnode];
    void init()
    {
        fail[0]=0;
        for(int i=0;i<childnum;i++)
        {
            ID[i]=i;
        }
        ID['A']=1;ID['G']=2;
        ID['C']=3;ID['T']=4;
    }
    void reset()
    {
        memset(chd,0,sizeof(chd));
        sz=1;
    }
    void insert(char str[],int k)
    {
        int p=0;
        int len=strlen(str);
        for(int i=0;i<len;i++)
        {
            int c=ID[str[i]];
            if(!chd[p][c])
            {
                memset(chd[sz],0,sizeof(chd[sz]));
                val[sz]=0;
                chd[p][c]=sz++;
            }
            p=chd[p][c];
        }
        val[p]=k;
    }
    void ac_build()
    {
        int *s=Q,*e=Q;
        for(int i=1;i<childnum;i++)
        {
            if(chd[0][i])
            {
                fail[chd[0][i]]=0;
                *e++=chd[0][i];
            }
        }
        while(s!=e)
        {
            int u=*s++;
            if(val[fail[u]])val[u]+=val[fail[u]];
            for(int i=1;i<childnum;i++)
            {
                int &v=chd[u][i];
                if(v)
                {
                    *e++=v;
                    fail[v]=chd[fail[u]][i];
                  //  val[v]=(val[v]+val[fail[v]]);
                }
                else v=chd[fail[u]][i];
            }
        }
    }
    int work(char str[])
    {
        int len=strlen(str);
        int i,j,k;
        for(i=0;i<=len;i++)
            for(j=0;j<sz;j++)dp[i][j]=INF;
        dp[0][0]=0;
        int cr,x;
        for(i=0;i<len;i++)
        {
            for(j=0;j<sz;j++)
            {
                if(dp[i][j]==INF)continue;
                for(k=1;k<childnum;k++)
                {
                    cr=chd[j][k];
                    if(val[cr])continue;
                    x=dp[i][j];
                    if(k!=ID[str[i]])x++;
                    dp[i+1][cr]=min(dp[i+1][cr],x);
                }
            }
        }
        int maxx=INF;
        for(j=0;j<sz;j++)
        {
            maxx=min(maxx,dp[len][j]);
        }
        if(maxx==INF)cout<<"-1"<<endl;
        else cout<<maxx<<endl;
    }
}AC;
char tmp[1550];
int main()
{
    AC.init();
    int n,m,k,x;
    int T;
    T=0;
    while(~scanf("%d",&n)&&(n))
    {
        T++;
        AC.reset();
        for(int i=1;i<=n;i++)
        {

            scanf("%s",tmp);
            AC.insert(tmp,1);
        }
        AC.ac_build();
        scanf("%s",tmp);
        printf("Case %d: ",T);
        AC.work(tmp);
    }
    return 0;
}

2，zoj-3228-Searching the String

题目大意：给出一个字符串和若干个单词。问这些单词在字符串里面出现了多少次。单词前面为0表示这个单词可重叠出现。1为不可重叠出现。


做法： 可重叠的非常优点理，就是AC自己主动机处理。不可重叠的就记录下上次这个单词出现的位置。假设上次出现的位置加上这个单词的长度小于等于当前位置的话，那么这个单词的次数就加一。否则就不加。

注意：可能存在两个字符串相等，比較坑爹。。。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<string.h>
#include<math.h>
using namespace std;
#define LL __int64
#define maxn 55
const int maxnode=6*110000;
const int childnum=27;
const int mod=1000000007;
const int INF=99999999;
struct ac_tree
{
    int chd[maxnode][childnum];
    int val[maxnode][2];
    int fail[maxnode];
    int last[maxnode];
    int num[maxnode][2];
    int *ans[maxnode];
    int key[1<<11];
    int Q[maxnode];
    int ID[128];
    int sz;
    void init()
    {
        fail[0]=0;
        for(int i=0;i<childnum;i++)
        {
            ID[i+'a']=i+1;
        }
    }
    void reset()
    {
        memset(chd,0,sizeof(chd));
        memset(num,0,sizeof(num));
        sz=1;
    }
    void insert(char str[],int k,int tt)
    {
        int p=0;
        int len=strlen(str);
        for(int i=0;i<len;i++)
        {
            int c=ID[str[i]];
            if(!chd[p][c])
            {
                memset(chd[sz],0,sizeof(chd[sz]));
                val[sz][tt]=0;
                chd[p][c]=sz++;
            }
            p=chd[p][c];
        }
        val[p][tt]=len;
        last[p]=-1;
        ans[k]=&num[p][tt];
    }
    void ac_build()
    {
        int *s=Q,*e=Q;
        for(int i=1;i<childnum;i++)
        {
            if(chd[0][i])
            {
                fail[chd[0][i]]=0;
                *e++=chd[0][i];
            }
        }
        while(s!=e)
        {
            int u=*s++;
            //if(val[fail[u]])val[u]+=val[fail[u]];
            for(int i=1;i<childnum;i++)
            {
                int &v=chd[u][i];
                if(v)
                {
                    *e++=v;
                    fail[v]=chd[fail[u]][i];
                  //  val[v]=(val[v]+val[fail[v]]);
                }
                else v=chd[fail[u]][i];
            }
        }
    }
    int work(char str[],int n)
    {
        int len=strlen(str);
        int root=0,key,tp,x;
        for(int i=0;i<len;i++)
        {
            tp=ID[str[i]];
            root=chd[root][tp];
            key=root;
            while(key!=0)
            {
                if(val[key][0]!=0)num[key][0]++;
                if(val[key][1]!=0)
                {
                    if(last[key]<=i-val[key][1])
                    {
                        num[key][1]++;
                        last[key]=i;
                    }
                }
                key=fail[key];
            }
        }
        for(int i=1;i<=n;i++)
            printf("%d\n",*ans[i]);
        puts("");
    }
}AC;
char tmp[1550];
char as[110000];
int main()
{
    AC.init();
    int n,m,k,x;
    int T;
    T=0;
    while(~scanf("%s",as))
    {
        T++;
        AC.reset();
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            scanf("%d %s",&k,tmp);
            AC.insert(tmp,i,k);
        }
        AC.ac_build();
        printf("Case %d\n",T);
        AC.work(as,n);
    }
    return 0;
}

3，hdu-3341-Lost's revenge

抄的解题报告，感觉说的非常具体。我就不赘余了。

。

 题意：给出一些病毒串，一个原串，问怎么调整原串的顺序使得跟最多的病毒串匹配

    抄解题报告：
    自己主动机+DP。设主串有na个A、nc个C、ng个G、nt个T，于是题意转化为用na个A、
    nc个C、ng个G、nt个T生成一个新串，使模式串匹配次数最大。

先将模式串生成自己主动机
    〔trie图〕，然后在这上面进行DP。状态可表示为dp[d,s]，d为自己主动机状态。
    s表示由ma个A、mc个C、mg个G、mt个T的生成串
    〔s可表示为ma*(nc+1)*(ng+1)*(nt+1)+mc*(ng+1)*(nt+1)+mg*(nt+1)+mt〕。
    转移为O(4)，总复杂度O(500*11^4*4) 
    
    那种表示方法就是变进制吧

    直接DP(root,s)会超时
    Qinz说这题卡时紧
    我用他的那种dfs才干过。他是先dfs枚举出状态，然后对这个状态递推计算。好快

    比較奇妙，不用管顺序的，就记录个数

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<string.h>
#include<math.h>
using namespace std;
#define LL __int64
#define maxn 55
const int maxnode=51*10;
const int childnum=5;
const int mod=1000000007;
const int INF=99999999;
struct ac_tree
{
    int chd[maxnode][childnum];
    int val[maxnode];
    int fail[maxnode];
    int Q[maxnode];
    int ID[128];
    int sz;
    int dp[maxnode][14642];
    void init()
    {
        fail[0]=0;
        for(int i=0;i<childnum;i++)
        {
            ID[i+'a']=i+1;
        }
        ID['A']=1;ID['T']=2;
        ID['G']=3;ID['C']=4;
    }
    void reset()
    {
        memset(chd,0,sizeof(chd));
        memset(val,0,sizeof(val));
        sz=1;
    }
    void insert(char str[],int k)
    {
       // cout<<str<<endl;
        int p=0;
        int len=strlen(str);
        for(int i=0;i<len;i++)
        {
            int c=ID[str[i]];
            if(!chd[p][c])
            {
                memset(chd[sz],0,sizeof(chd[sz]));
                val[sz]=0;
                chd[p][c]=sz++;
            }
            p=chd[p][c];
        }
        val[p]+=k;
        //cout<<p<<" "<<val[p]<<endl;
    }
    void ac_build()
    {
        int *s=Q,*e=Q;
        for(int i=1;i<childnum;i++)
        {
            if(chd[0][i])
            {
                fail[chd[0][i]]=0;
                *e++=chd[0][i];
            }
        }
        while(s!=e)
        {
            int u=*s++;
            if(val[fail[u]])val[u]+=val[fail[u]];
            for(int i=1;i<childnum;i++)
            {
                int &v=chd[u][i];
                if(v)
                {
                    *e++=v;
                    fail[v]=chd[fail[u]][i];
                  //  val[v]=(val[v]+val[fail[v]]);
                }
                else v=chd[fail[u]][i];
            }
        }
    }
    int work(char str[])
    {
        int num[5];
        memset(num,0,sizeof(num));
        int len=strlen(str);
        for(int i=0;i<len;i++)num[ID[str[i]]]++;
        dp[0][0]=0;
        int tai,cr;
        int sum[6];
        sum[5]=1;
        sum[4]=num[4]+1;
        sum[3]=(num[3]+1)*sum[4];
        sum[2]=(num[2]+1)*sum[3];
        sum[1]=(num[1]+1)*sum[2];
        int a[5],i,j;
        int pt;
        memset(dp,-1,sizeof(dp));
        dp[0][0]=0;
        for(a[1]=0;a[1]<=num[1];a[1]++)
        for(a[2]=0;a[2]<=num[2];a[2]++)
        for(a[3]=0;a[3]<=num[3];a[3]++)
        for(a[4]=0;a[4]<=num[4];a[4]++)
        {
            if(a[1]+a[2]+a[3]+a[4]>=len)break;
            tai=0;
            for(i=1;i<=4;i++)tai+=a[i]*sum[i+1];
            for(i=0;i<sz;i++)
            {
                if(dp[i][tai]==-1)continue;
                for(j=1;j<childnum;j++)
                {
                    if(a[j]+1>num[j])continue;
                    cr=chd[i][j];
                    pt=tai+sum[j+1];
                   // if(dp[cr][pt]==-1)dp[cr][pt]=dp[i][tai];
                    dp[cr][pt]=max(dp[cr][pt],dp[i][tai]+val[cr]);
                   // cout<<i<<" "<<j<<"->"<<cr<<" "<<pt<<" "<<dp[cr][pt]<<endl;
                }
            }
        }
        pt=num[1]*sum[2]+num[2]*sum[3]+num[3]*sum[4]+num[4];
        int maxx=-1;
        for(i=0;i<sz;i++)
        {
            maxx=max(maxx,dp[i][pt]);
        }
        cout<<maxx<<endl;
    }
}AC;
char tmp[1550];
char as[110000];
int main()
{
    AC.init();
    int n,m,k,x;
    int T;
    T=0;
    while(~scanf("%d",&n)&&n)
    {
        T++;
        AC.reset();
        for(int i=1;i<=n;i++)
        {
            scanf("%s",tmp);
            AC.insert(tmp,1);
        }
        AC.ac_build();
        scanf("%s",as);
        printf("Case %d: ",T);
        AC.work(as);
    }
    return 0;
}

4，hdu-3247-Resource Archiver

题意：

给你 n 个串。和 m 个病毒串。要把这 n 个串
连起来来，能够重叠，但不能包括 m 个病毒串
中的随意一个。求把 n 个串连起来的最小长度。

做法：这个题目憋了我非常长时间，一直不知道怎么样处理。后来经过翻阅博客。最终悟出来点。

把病毒串和非病毒串都标记在trie树上处理。然后病毒串的地方标记为病毒串，非病毒串的地方标记为是哪一个串。

状态压缩一下。

然后从每一个非病毒串的结尾開始bfs。

map[i][j]:从i字符串的结尾。到j字符串的结尾的最短路径是多少。

然后就能够DP了。

dp[i][j]:已用的字符串为i状态，在trie树上的点为j状态。的最短路径。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<string.h>
#include<math.h>
using namespace std;
#define LL __int64
#define maxn 205
const int maxnode=100001;
const int childnum=3;
const int mod=1000000007;
const int INF=99999999;
struct list
{
    int st;
    int x;
}pp,qq;
struct ac_tree
{
    int chd[maxnode][childnum];
    int val[maxnode];
    int fail[maxnode];
    int Q[maxnode];
    int var[maxnode];
    int vis[maxnode];
    int dist[maxnode];
    int st[maxn];
    int ID[128];
    int sz;
    int maps[maxn][maxn];
    int ns;
    int dp[1<<11][maxn];
    void init()
    {
        fail[0]=0;
        for(int i=0;i<childnum;i++)
        {
            ID[i+'a']=i+1;
        }
        ID['0']=1;ID['1']=2;
    }
    void reset()
    {
        memset(chd,0,sizeof(chd));
        memset(val,0,sizeof(val));
        memset(var,0,sizeof(var));
        memset(maps,-1,sizeof(maps));
        sz=1;
    }
    void insert(char str[],int k,int ps)
    {
       // cout<<str<<endl;
        int p=0;
        int len=strlen(str);
        for(int i=0;i<len;i++)
        {
            int c=ID[str[i]];
            if(!chd[p][c])
            {
                memset(chd[sz],0,sizeof(chd[sz]));
                val[sz]=0;
                chd[p][c]=sz++;
            }
            p=chd[p][c];
        }
        if(ps==0)
        {
            val[p]=k;
            var[p]=0;
        }
        else var[p]=1;
        //cout<<p<<" "<<val[p]<<endl;
    }
    void ac_build()
    {
        int *s=Q,*e=Q;
        for(int i=1;i<childnum;i++)
        {
            if(chd[0][i])
            {
                fail[chd[0][i]]=0;
                *e++=chd[0][i];
            }
        }
        while(s!=e)
        {
            int u=*s++;
            //if(val[fail[u]]==-1)val[u]=-1;
            for(int i=1;i<childnum;i++)
            {
                int &v=chd[u][i];
                if(v)
                {
                    *e++=v;
                    fail[v]=chd[fail[u]][i];
                    val[v]=(val[v]|val[fail[v]]);
                    var[v]=(var[v]|var[fail[v]]);
                }
                else v=chd[fail[u]][i];
            }
        }
    }
    int bfs(int u)
    {
        queue<int>que;
        while(!que.empty())que.pop();
        int x=st[u];
        que.push(x);
        memset(dist,-1,sizeof(dist));
        dist[x]=0;
        while(!que.empty())
        {
            x=que.front();
            que.pop();
            for(int i=1;i<childnum;i++)
            {
                int y=chd[x][i];
                if(var[y])continue;
                if(dist[y]<0)
                {
                    dist[y]=dist[x]+1;
                    que.push(y);
                }
            }
        }
        for(int i=0;i<ns;i++)
        {
            maps[u][i]=dist[st[i]];
            //cout<<u<<"->"<<i<<"="<<maps[u][i]<<endl;
        }
    }
    int work(int n)
    {
        st[0]=0;
        ns=1;
        for(int i=0;i<sz;i++)
            if(val[i])
            {
                st[ns++]=i;
                //cout<<ns-1<<" "<<val[st[ns-1]]<<endl;
            }
        for(int i=0;i<ns;i++)bfs(i);
        memset(dp,-1,sizeof(dp));
        dp[0][0]=0;
        int cr;
        for(int i=0;i<(1<<n);i++)
        {
            for(int j=0;j<ns;j++)
            {
                if(dp[i][j]<0)continue;
                for(int k=0;k<ns;k++)
                {
                    if(maps[j][k]<0)continue;
                    cr=i|val[st[k]];
                    if(dp[cr][k]==-1)dp[cr][k]=dp[i][j]+maps[j][k];
                    else dp[cr][k]=min(dp[cr][k],dp[i][j]+maps[j][k]);
                   // cout<<cr<<" "<<k<<" "<<dp[cr][k]<<endl;
                }
            }
        }
        int minn=-1;
        cr=(1<<n)-1;
        for(int i=0;i<ns;i++)
        {
            if(dp[cr][i]==-1)continue;
            if(minn<0)minn=dp[cr][i];
            minn=min(minn,dp[cr][i]);
        }
        cout<<minn<<endl;
    }

}AC;
char tmp[1550];
int main()
{
    AC.init();
    int n,m,k,x;
    int T;
    T=0;
    while(~scanf("%d%d",&n,&m)&&(n||m))
    {
        AC.reset();
        for(int i=1;i<=n;i++)
        {
            scanf("%s",tmp);
            AC.insert(tmp,1<<(i-1),0);
        }
        for(int i=1;i<=m;i++)
        {
            scanf("%s",tmp);
            AC.insert(tmp,1,1);
        }
        AC.ac_build();
        AC.work(n);
    }
    return 0;
}























weixin_34007906
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
每日练习题5-10题（ 6.4至9.18）
weixin_44587063的博客
10-28 1255
【每日练习-6.4】 1、一名关键相关方担心下一个工作包的交付以及与下个阶段相关的成本。项目经理可以从哪里找到这个信息? A.问题日志报告 B.采购工作说明书(SOW) C.工作绩效报告 D.控制图 参考答案：C 解析：整合管理的监控项目工作过程会输出工作绩效报告，包括状态报告和进展报告，报告中含挣值图表和信息、趋势线和预测、储备燃尽图、缺陷直方图、合同绩效信息等。 题干中项目经理要获取相关方担忧的下一个工作包的交付以及与下个阶段相关的成本这个信息，可在工作绩效报告中找到。 -------
Shiny-dailyRe：每日Covid-19 Re估算的R Shiny应用程序
01-31
Shiny-dailyRe：每日Covid-19 Re估算的R Shiny应用程序
每日学习打卡-汇总处
大林程序员
04-03 3057
无，就是一个打卡而已
材料化学博士后->谷歌offer的转行总结 -- 转自一亩三分地
AuburnTigers的博客
10-17 8517
不知道发在这个版对不对，这篇文章记录了我转行的大致经过和心态的变化，希望对另一些正在经历同样过程的人有些许帮助。 -------------------------------------------------------------为什么转行------------------------------------------------------------ 我的专业是材料化学，在读博期间就...
谷粒商城 -- 项目环境搭建
lwj_07的博客
11-12 4912
注：以下的项目环境搭建过程，适用于所有的微服务项目的环境搭建，以后做微服务项目的时候看着这个笔记进行搭建环境即可。
lb3d-2014-05-19.zip_LB3D_lb3d-2014-05-19_格子_格子玻尔兹曼
07-14
格子玻尔兹曼的3D程序代码 有需要的可以下载下来参考
H19-368（最新版）.pdf
04-16
H19-368（最新版）.pdf
Android SDK (SDK Platforms)-android-19.zip
01-10
Android SDK (SDK Platforms)-android-19.zip
最新华为售前H19-366题库
09-24
最新华为售前H19-366题库
一个用于配置移动应用开发环境的自动化脚本
04-17
可以帮助开发者自动安装Android SDK、Android NDK、Java开发工具包（JDK）以及Flutter SDK，这些都是移动应用开发（特别是Android和Flutter应用）所必需的。 脚本首先定义了一些变量，用于存储工具的安装路径和版本。然后，定义了一个install_tool函数，用于检查工具是否已安装，如果没有安装则执行安装命令。 接着，脚本定义了install_android_sdk、install_android_ndk、install_java_jdk、set_java_env和install_flutter_sdk等函数，分别用于安装Android SDK、Android NDK、Java JDK、设置Java环境变量以及安装Flutter SDK。 在主程序部分，脚本按照顺序调用这些函数来安装和配置各个工具。安装完成后，脚本会输出一条消息表示配置已完成。
AI Agent智能应用从0到1定制开发
04-17
AI Agent智能应用从0到1定制开发 关键特点： 自动化：AI Agent可以自动执行重复性任务，提高效率并减少人力成本。 智能决策：基于复杂的算法，AI Agent能够进行决策支持，分析数据并提供洞察。 自然语言处理：许多AI Agent具备理解和生成自然语言的能力，使其能够与人类用户进行交流。 机器学习：AI Agent可以利用机器学习技术从经验中学习，不断优化其性能。 个性化：AI Agent能够根据用户的行为和偏好提供个性化的体验。 可扩展性：AI Agent可以设计成模块化，方便扩展新功能或适应不同规模的需求。 实时响应：AI Agent能够提供快速的实时响应，满足紧急任务的需求。
魔方PPT模板04_动态清新绿色学术答辩模板.pptx.zip
04-17
魔方PPT模板04_动态清新绿色学术答辩模板.pptx
tomcat概述.pdf
04-17
Tomcat是一个广泛使用的开源Web服务器和Servlet容器，它是由Apache软件基金会（ASF）主持的一个项目。Tomcat实现了Java Servlet、JavaServer Pages（JSP）、Java Expression Language（JSTL）和WebSocket等技术规范，并提供了一个用于运行Java Web应用程序的运行时环境。由于其稳定性、可扩展性和灵活性，Tomcat已成为许多企业级Java Web应用程序的首选服务器。 Tomcat最初是由Sun Microsystems在1999年作为Servlet API 2.2和JSP 1.1规范的参考实现而开发的。自那时以来，Tomcat不断发展壮大，成为了一个功能强大且易于使用的Web服务器和Servlet容器。Tomcat的开源性质和广泛的支持使得它成为了许多开发者和企业的首选。
基于Qt+C++实现的各种炫酷的样式表+源码
04-17
用法链接：https://menghui666.blog.csdn.net/article/details/137888208?spm=1001.2014.3001.5502 基于Qt+C++实现的各种炫酷的样式表，如单选、多选、按钮、日历、表格、下拉框、滚轮等，+源码 基于Qt+C++实现的各种炫酷的样式表，如单选、多选、按钮、日历、表格、下拉框、滚轮等，+源码 基于Qt+C++实现的各种炫酷的样式表，如单选、多选、按钮、日历、表格、下拉框、滚轮等，+源码
罗茨泵设计sw17可编辑含工程图设计图纸.7z
04-17
罗茨泵设计sw17可编辑含工程图设计图纸.7z
计算机思维训练+C语言
04-17
计算机思维训练+C语言
基于JAVA毕业设计-JAVA基于遗传算法的中药药对挖掘系统的设计与实现(源代码+论文).rar
04-17
基于JAVA毕业设计-JAVA基于遗传算法的中药药对挖掘系统的设计与实现(源代码+论文).rar 用数据挖掘技术研究了中药方剂配伍的规律。主要工作：分析了关联规则存在的问题，引入双向关联规则的概念；介绍了遗传算法的基本原理，研究了遗传算法在数据挖掘中的应用；将方剂库转换为位图矩阵，大大提高搜索效率；开发了一个基于遗传算法的中药药对药组挖掘系统。论文组织如下：介绍了研究背景和意义；阐述了相关的理论基础；提出了系统的设计方案；详细展示了基于遗传算法的双向关联规则挖掘系统的实现过程，包括位图矩阵的实现，个体的编码方法，适应度函数的设计，规则的提取，选择、交叉、变异等遗传操作的实现等；利用脾胃类方剂库对系统进行了测试，并对测试结果进行了分析。结果证明：该系统能够快速高效地从方剂库中找出具有重要意义的药对药组，对中医药的研究发展有一定意义。
C常用算法程序集数值计算数值积分
最新发布
04-17
C常用算法程序集数值计算数值积分提取方式是百度网盘分享地址
前端如何比较2023-05-16 和2023-05-19 大小
05-05
console.log('2023-05-16 小于 2023-05-19'); } else if (time1 > time2) { console.log('2023-05-16 大于 2023-05-19'); } else { console.log('两个日期相等'); } ``` 注意，如果比较的日期字符串格式不是标准...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值