杭电多校HDU 6586 String(序列自动机 贪心)题解

题意:

给你一个串,现需要你给出一个子序列,满足26个约束条件,\(len(A_i) >= L_i\) 且 \(len(a) <= R_i\), \(A_i\)为从a到z的26个字母。

思路:

先用序列自动机(?)构造出某个位置后每个字母的个数,每个字母 的第一个位置。
然后每次贪心地加入最小的字符,加入的条件为当前字母加入后,后面的字符满足剩余的条件。
即剩余的字母在不超R_i的情况下能构成k长度的串,剩余的字母\(A_i+\)已拿取字母\(A_i >= L_i\)且满足\(L_i\)所需的长度小于剩余可添加长度。
官方题解:

代码:

#include<cstdio>
#include<set>
#include<cmath>
#include<stack>
#include<vector>
#include<queue>
#include<cstring>
#include<string>
#include<sstream>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;
const int maxn = 1e5 + 5;
const ll INF = 1e18;
int nex[maxn][30];
char s[maxn];
int len, k;
int l[30], r[30];
int cnt[maxn][30], getnum[30];
char ans[maxn];
bool check(int pos, int nowlen){
    int len = 0;
    int dis = 0;
    for(int i = 0; i < 26; i++){
        if(getnum[i] + cnt[pos][i] < l[i]) return false;
        len += getnum[i] + min(r[i] - getnum[i], cnt[pos][i]);
        dis += max(0, l[i] - getnum[i]);
    }
    if(len < k) return false;
    if(dis > k - nowlen) return false;
    return true;
}
int main(){
    while(~scanf("%s%d", s + 1, &k)){
        len = strlen(s + 1);
        for(int i = 0; i < 26; i++){
            scanf("%d%d", &l[i], &r[i]);
        }

        memset(nex[len], -1, sizeof(nex[len]));
        memset(cnt[len], 0, sizeof(cnt[len]));
        for(int i = len - 1; i >= 0; i--){
            for(int j = 0; j < 26; j++){
                nex[i][j] = nex[i + 1][j];
                cnt[i][j] = cnt[i + 1][j];
            }
            nex[i][s[i + 1] - 'a'] = i + 1;
            cnt[i][s[i + 1] - 'a']++;
        }

        memset(getnum, 0, sizeof(getnum));
        int pos = 0, tot = 0;
        bool ok = true;
        while(pos <= len && tot < k){
            bool can = false;
            for(int i = 0; i < 26; i++){
                if(nex[pos][i] != -1 && getnum[i] < r[i]){
                    getnum[i]++;
                    if(check(nex[pos][i], tot + 1)){
                        can = true;
                        ans[tot++] = i + 'a';
                        pos = nex[pos][i];
                        break;
                    }
                    getnum[i]--;
                }
            }
            if(!can){
                ok = false;
                break;
            }
        }
        ans[tot] = '\0';
        if(ok) printf("%s\n", ans);
        else printf("-1\n");
    }
    return 0;
}

原文地址:https://www.cnblogs.com/KirinSB/p/11230888.html

时间: 2024-10-09 12:34:29

杭电多校HDU 6586 String(序列自动机 贪心)题解的相关文章

HDU 4937 (杭电多校 #7 1003题)Lucky Number(瞎搞)

题目地址:HDU 4937 多校的题以后得重视起来...每道题都错好多次...很考察细节.比如这道....WA了无数次.... 这题的思路自己真心想不到...这题是将进制后的数分别是1位,2位,3位和更多位的分开来计算. 当是1位的时候,显然只有3到6,此时只能是-1 当是2位的时候,可以转换成一元一次方程求解 当是3位的时候,可以转换成一元二次方程求解 当是4位的时候,此时最多也只有7000个数,7000^3接近1e12.所以剩下的直接枚举进制数来判断即可. 代码如下: #include <i

HDU 4975 (杭电多校 #10 1005题)A simple Gaussian elimination problem.(网络流之最大流)

题目地址:HDU 4975 对这题简直无语...本来以为这题要用什么更先进的方法,结果还是老方法,这么卡时间真的好吗....比赛的时候用了判环的方法,一直TLE..后来换了矩阵DP的方式,加了加剪枝就过了..无语了.. 代码如下: #include <cstdio> #include <cstring> #include <algorithm> #include <iostream> #include <cstdio> #include <

HDU 4888 (杭电多校#3)Redraw Beautiful Drawings(网络流之最大流)

题目地址:HDU 4888 自己之所以弱真心是态度的问题,以后不能再偷懒了!!那次这个题一直没补,结果这次又遇到了..还有这次遇到的最小割权闭合问题,也一直没刷,所以这次遇到了也不会,连是最小割都不知道!!(突然想起来前面还有好多题拖到现在也没做...T U T)以后绝不能再拖拉了! 这题的建图是很容易的,主要是判断唯一性不好判断.这里是用的dfs找环来判断是否唯一,因为假如有环的话,说明环 中的数字是可以相互流动而且可以保证解依然正确.. 代码如下: #include <cstdio> #i

HDU 4920(杭电多校训练#5 1010 题) Matrix multiplication(不知道该挂个什么帽子。。。)

题目地址:HDU 4920 对这个题简直无语到极点...居然O(n^3)的复杂度能过....方法有三.. 1:进行输入优化和输出优化..(前提是你的输入优化不能太搓...) 2:利用缓存优化..详情请看该论文.大体就是将后两个for循环换过来,让坐标改变的频率降下来. 3:叉姐题解中说的正规方法..利用biset存储,进行预处理..(其实我还没看懂.. 我只写了个第二种...代码如下,共勉..神奇的小代码.. #include <iostream> #include <cstdio>

HDU 4902 Nice boat 2014杭电多校训练赛第四场F题(线段树区间更新)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4902 解题报告:输入一个序列,然后有q次操作,操作有两种,第一种是把区间 (l,r) 变成x,第二种是把区间 (l,r) 中大于x的数跟 x 做gcd操作. 线段树区间更新的题目,每个节点保存一个最大和最小值,当该节点的最大值和最小值相等的时候表示这个区间所有的数字都是相同的,可以直接对这个区间进行1或2操作, 进行1操作时,当还没有到达要操作的区间但已经出现了节点的最大值跟最小值相等的情况时,说明

HDU 5742 It&#39;s All In The Mind (贪心) 2016杭电多校联合第二场

题目:传送门. 题意:求题目中的公式的最大值,且满足题目中的三个条件. 题解:前两个数越大越好. #include <iostream> #include <algorithm> #include <cstdio> #include <cstring> using namespace std; int gcd(int a,int b) { if(!b) return a; return gcd(b,a%b); } int main() { int t; ci

HDU 4940(杭电多校#7 1006) Destroy Transportation system(瞎搞)

题目地址:HDU 4940 当时这个题一看就看出来了是网络流的最小割,然后就一直在想建图..然后突然发现,应该要让T集合的数目最少,不然只要有两个,那这两个的每一个都可以跑到S集合,使得T集合变小.那就只能是1个了.然后..枚举就好了..但是虽然觉得这么做肯定没错..但是不敢敲..因为当时都3个小时了才只有10个队过了...后来又想了几遍后觉得这样没错,就写完交上了.果然AC... 代码如下: #include <iostream> #include <cstdio> #inclu

HDU 4901(杭电多校训练#3 1005题)The Romantic Hero(DP)

题目地址:HDU 4901 这题没想到最后居然能够做出来.... 这题用了两次DP,先从前往后求一次异或的,再从后往前求一次与运算的.分别是 1:求异或的时候,定义二维数组huo[1000][1024],前者指第几位,后者是哈希的思想,若huo[x][y]=2则表示最右边的数为第x位时,异或值为y的出现了两次,需要再定义一个hash数组,来保存前面出现的所有情况,再找有多少位的时候,用hash数组中出现的所有的值与当前的第x位的数字进行异或. 2:求与的时候,定义二维数组yu[1000][102

HDU 4970(杭电多校#9 1011题)Killing Monsters(瞎搞)

题目地址:HDU 4970 先进行预处理,在每个炮塔的火力范围边界标记一个点.然后对每个点的伤害值扫一遍就能算出来.然后在算出每个点到终点的总伤害值,并保存下来,也是扫一遍即可.最后在询问的时候直接判断即可,复杂度O(2*n). 代码如下: #include <cstdio> #include <cstring> #include <algorithm> using namespace std; #define maxn 110000 #define LL __int6