HDU-3695-ac自动机

本文详细介绍了AC自动机的实现原理及其在字符串匹配问题中的应用。通过具体的代码示例,展示了如何构建AC自动机,包括插入字符串、建立失败指针以及进行模式匹配等关键步骤。此外,还提供了一个完整的主函数示例,演示了如何读取输入数据并使用AC自动机进行处理。

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

char str1[5100009], str2[5100009];
int cnt;

struct trie
{
    trie *ch[26];
    trie *fail;
    int end;
    void init()
    {
        memset(ch, NULL, sizeof(ch));
        fail = NULL;
        end = 0;
    }
}*root, t[maxn];

void insert(char *s)
{
    trie *p = root;
    for(int i=0; s[i]; i++)
    {
        //cout<<i<<' '<<s[i]<<endl;
        int k = s[i]-'A';
        if(p->ch[k]==NULL)
        {
            t[cnt].init();
            p->ch[k] = &t[cnt++];
        }
        p = p->ch[k];
    }
    p->end = 1;
}

queue<trie*>q;
void build_fail()
{
    q.push(root);
    root->fail = root;
    while(!q.empty())
    {
        trie *p = q.front();
        q.pop();
        for(int k=0; k<26; k++)
        if(p->ch[k]!=NULL)
        {
            q.push(p->ch[k]);
            if(p==root)
            {
                p->ch[k]->fail = root;
                continue;
            }
            trie *tmp = p->fail;
            while( tmp!=root && tmp->ch[k]==NULL)
                tmp = tmp->fail;
            if(tmp->ch[k]) p->ch[k]->fail = tmp->ch[k];
            else p->ch[k]->fail = root;
        }
    }
}

int query(char *a)
{
    int ans = 0;
    trie *p = root;
    for(int i=0; a[i]; i++)
    {
        if(a[i]<'A' || a[i]>'Z')
        {
            p = root;
            continue;
        }
        int k = a[i]-'A';
        while(p->ch[k]==NULL && p!=root) p=p->fail;
        p = p->ch[k];
        p = (p==NULL)? root : p;
        trie *tmp = p;
        while(tmp!=root && tmp->end!=0)
        {
            ans++;
            tmp->end = 0;
            tmp = tmp->fail;
        }
    }
    return ans;
}

int main()
{
    int tt, n, i, j;
    scanf("%d", &tt);
    while(tt--)
    {
        cnt = 1;
        t[0].init();
        root = &t[0];
        scanf("%d", &n);
        while(n--)
        {
            scanf("%s", str1+1);
            for(i=1, j=1; str1[i]; i++)
            {
                if(str1[i]>='A' && str1[i]<='Z') str2[j++] = str1[i];
                else
                {
                    i++;
                    int k = str1[i]-'0';
                    i++;
                    while(str1[i]>='0'&&str1[i]<='9') k = k*10+ str1[i++]-'0';
                    while(k--) str2[j++] = str1[i];
                    i++;
                }
            }
            str2[j] = '\0';
            insert(str2+1);
        }
        build_fail();

        scanf("%s", str1+1);
        for(i=1, j=1; str1[i]; i++)
        {
            if(str1[i]>='A' && str1[i]<='Z') str2[j++] = str1[i];
            else
            {
                i++;
                int k = str1[i]-'0';
                i++;
                while(str1[i]>='0'&&str1[i]<='9') k = k*10+ str1[i++]-'0';
                while(k--) str2[j++] = str1[i];
                i++;
            }
        }
        str2[j] = '\0';
            //cout<<str2+1<<endl;
        int ans = query(str2+1);
        for(i=1, j=strlen(str2+1); i<j; i++, j--)
            swap(str2[i], str2[j]);
        ans += query( str2+1 );
        printf("%d\n", ans);
    }
	return 0;
}


HDU-3480 是一个典型的动态规划问题,其题目标题通常为 *Division*,主要涉及二维费用背包问题或优化后的动态规划策略。题目大意是:给定一个整数数组,将其划分为若干个连续的子集,每个子集最多包含 $ m $ 个元素,并且每个子集的最大值与最小值之差不能超过给定的阈值 $ t $,目标是使所有子集的划分代价总和最小。每个子集的代价是该子集最大值与最小值的差值。 ### 动态规划思路 设 $ dp[i] $ 表示前 $ i $ 个元素的最小代价。状态转移方程如下: $$ dp[i] = \min_{j=0}^{i-1} \left( dp[j] + cost(j+1, i) \right) $$ 其中 $ cost(j+1, i) $ 表示从第 $ j+1 $ 到第 $ i $ 个元素构成一个子集的代价,即 $ \max(a[j+1..i]) - \min(a[j+1..i]) $。 为了高效计算 $ cost(j+1, i) $,可以使用滑动窗口或单调队列等数据结构来维护区间最大值与最小值,从而将时间复杂度优化到可接受的范围。 ### 示例代码 以下是一个简化版本的动态规划实现,使用暴力方式计算区间代价,适用于理解问题结构: ```cpp #include <bits/stdc++.h> using namespace std; const int INF = 0x3f3f3f3f; const int MAXN = 10010; int a[MAXN]; int dp[MAXN]; int main() { int T, n, m; cin >> T; for (int Case = 1; Case <= T; ++Case) { cin >> n >> m; for (int i = 1; i <= n; ++i) cin >> a[i]; dp[0] = 0; for (int i = 1; i <= n; ++i) { dp[i] = INF; int mn = a[i], mx = a[i]; for (int j = i; j >= max(1, i - m + 1); --j) { mn = min(mn, a[j]); mx = max(mx, a[j]); if (mx - mn <= T) { dp[i] = min(dp[i], dp[j - 1] + mx - mn); } } } cout << "Case " << Case << ": " << dp[n] << endl; } return 0; } ``` ### 优化策略 - **单调队列**:可以使用两个单调队列分别维护当前窗口的最大值与最小值,从而将区间代价计算的时间复杂度从 $ O(n^2) $ 降低到 $ O(n) $。 - **斜率优化**:若问题满足特定的决策单调性,可以考虑使用斜率优化技巧进一步加速状态转移过程。 ### 时间复杂度分析 原始暴力解法的时间复杂度为 $ O(n^2) $,在 $ n \leq 10^4 $ 的情况下可能勉强通过。通过单调队列优化后,可以稳定运行于 $ O(n) $ 或 $ O(n \log n) $。 ### 应用场景 HDU-3480 的问题模型可以应用于资源调度、任务划分等场景,尤其适用于需要控制子集内部差异的问题,如图像分块压缩、数据分段处理等[^1]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值