[hdu5340]二分，枚举，二进制压位加速

题意：判断一个字符串能否划成三段非空回文串。

思路：先用二分+hash在nlogn的时间内求出以每条对称轴为中心的回文串的最大半径r[i]（可以用对称的两个下标之和来表示），然后利用r[i]求出pre[i]和suf[i]，其中pre[i]表示0~i能否形成回文串，suf[i]表示i~n-1能否形成回文串。然后枚举中间的第二段回文串的对称轴，利用半径r[i]得到最左端L和最右端R，问题变成能否找到一个数d，使得pre[L+d] && suf[R-d]，-1<=d，L+d<R-d，这显然可以用二进制来加速，移位，按位与，判断是否为0等操作都降低了常数倍复杂度。理论上复杂度变为O(n^2/64)，实际上跑起来慢爆了，可能是写挫了TUT......

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

/* ******************************************************************************** */

#include <iostream>                                                                 //

#include <cstdio>                                                                   //

#include <cmath>                                                                    //

#include <cstdlib>                                                                  //

#include <cstring>                                                                  //

#include <vector>                                                                   //

#include <ctime>                                                                    //

#include <deque>                                                                    //

#include <queue>                                                                    //

#include <algorithm>                                                                //

#include <map>                                                                      //

#include <cmath>                                                                    //

using namespace

std;

//

#define pb push_back                                                                //

#define mp make_pair                                                                //

#define X first                                                                     //

#define Y second                                                                    //

#define all(a) (a).begin(), (a).end()                                               //

#define fillchar(a, x) memset(a, x, sizeof(a))                                      //

//

typedef pair<int, int

> pii;

//

typedef long long

ll;

//

typedef unsigned long long ull; //

//

#ifndef ONLINE_JUDGE                                                                //

void RI(vector<int>&a,int n){a.resize(n);for(int i=0;i<n;i++)scanf("%d",&a[i]);} //

void RI(){}void RI(int&X){scanf("%d",&X);}template<typename...R> //

void RI(int&f,R&...r){RI(f);RI(r...);}void RI(int*p,int*q){int d=p<q?1:-1; //

while(p!=q){scanf("%d",p);p+=d;}}void print(){cout<<endl;}template<typename T> //

void print(const T t){cout<<t<<endl;}template<typename F,typename...R> //

void print(const F f,const R...r){cout<<f<<", ";print(r...);}template<typename T> //

void print(T*p, T*q){int d=p<q?1:-1;while(p!=q){cout<<*p<<", ";p+=d;}cout<<endl;} //

#endif // ONLINE_JUDGE                                                              //

template<typename T>bool umax(T&a, const T&b){return b<=a?false:(a=b,true);} //

template<typename T>bool umin(T&a, const T&b){return b>=a?false:(a=b,true);} //

template<typename

T>

//

void V2A(T a[],const vector<T>&b){for(int i=0;i<b.size();i++)a[i]=b[i];} //

template<typename

T>

//

void A2V(vector<T>&a,const T b[]){for(int i=0;i<a.size();i++)a[i]=b[i];} //

//

const double PI = acos(-1.0); //

const int

INF = 1e9 + 7;

//

/* -------------------------------------------------------------------------------- */

unsigned long long Pre[64], Suf[64];

struct BitSet {

vector<unsigned long long> s;

static void init() {

Pre[0] = 1;

Suf[63] = (unsigned long long)1 << 63;

for (int i = 1; i < 64; i ++) {

Pre[i] = (unsigned long long)1 << i | Pre[i - 1];

}

for (int i = 62; i >= 0; i --) {

Suf[i] = (unsigned long long)1 << i | Suf[i + 1];

}

void resize(int n) {

int p = s.size(), t = (n - 1) / 64 + 1;

s.resize(t);

}

BitSet(int n) {

resize(n);

}

BitSet() {}

BitSet operator & (BitSet &that) {

int sz = that.s.size(), n = this->s.size(), len = max(sz, n);

if (sz < len) that.resize(len);

if (n < len) this->resize(len);

BitSet ans(len * 64);

for (int i = len - 1; i >= 0; i --) {

ans.s[i] = this->s[i] & that.s[i];

}

return ans;

}

BitSet operator | (BitSet &that) {

int sz = that.s.size(), n = this->s.size(), len = max(sz, n);

if (sz < len) that.resize(len);

if (n < len) this->resize(len);

BitSet ans(len * 64);

for (int i = len - 1; i >= 0; i --) {

ans.s[i] = this->s[i] | that.s[i];

}

return ans;

}

BitSet operator ^ (BitSet &that) {

int sz = that.s.size(), n = this->s.size(), len = max(sz, n);

if (sz < len) that.resize(len);

if (n < len) this->resize(len);

BitSet ans(len * 64);

for (int i = len - 1; i >= 0; i --) {

ans.s[i] = this->s[i] ^ that.s[i];

}

return ans;

}

BitSet operator << (int x) {

int sz = s.size(), c = x / 64, r = x % 64;

BitSet ans(64 * sz);

for (int i = sz - 1; i - c >= 0; i --) {

ans.s[i] = (s[i - c] & Pre[63 - r]) << r;

if (r && i - c - 1 >= 0) ans.s[i] |= (s[i - c - 1 ] & Suf[64 - r]) >> (64 - r);

}

return ans;

}

BitSet operator >> (int x) {

int sz = s.size(), c = x / 64, r = x % 64;

BitSet ans(64 * sz);

for (int i = 0; i + c < sz; i ++) {

ans.s[i] = (s[i + c] & Suf[r]) >> r;

if (r && i + c + 1 < sz) ans.s[i] |= (s[i + c + 1] & Pre[r - 1]) << (64 - r);

}

return ans;

}

bool get(int p) {

int c = p / 64, r = p % 64;

return s[c] & ((unsigned long long)1 << r);

}

bool zero() {

int n = s.size();

for (int i = 0; i < n; i ++) {

if (s[i]) return false;

}

return true;

}

void setval(int L, int R, bool val) {

int p = L / 64, tp = L % 64, q = R / 64, tq = R % 64;

for (int i = p + 1; i < q; i ++) {

s[i] = val? ((unsigned long long)-1) : 0;

}

if (p == q) {

unsigned long long buf = Suf[tp] & Pre[tq];

s[p] = val? s[p] | buf : s[p] & ~buf;

return ;

}

s[p] = val? s[p] | Suf[tp] : s[p] & ~Suf[tp];

s[q] = val? s[q] | Pre[tq] : s[q] & ~Pre[tq];

}

void print() {

int n = s.size();

for (int i = n - 1; i >= 0; i --) {

unsigned long long x = s[i];

for (int i = 63; i >= 0; i --) {

if (((unsigned long long)1 << i) & x)

putchar('1');

else

putchar('0');

}

putchar('\n');

}

};

struct StringHash {

const static unsigned int hack = 1301;

const static int maxn = 1e5 + 7;

unsigned long long H[maxn], C[maxn];

void init(char s[], int n) {

for (int i = 0; s[i]; i ++) {

H[i] = (i? H[i - 1] * hack : 0) + s[i];

}

C[0] = 1;

for (int i = 1; i <= n; i ++) C[i] = C[i - 1] * hack;

}

unsigned long long get(int L, int R) {

return H[R] - (L? H[L - 1] * C[R - L + 1] : 0);

}

} ;

StringHash hsh, hshrev;

const int maxn = 1e5 + 7;

bool pre[maxn], suf[maxn];

char s[maxn], revs[maxn];

int F[maxn];

int main() {

#ifndef ONLINE_JUDGE

freopen("in.txt", "r", stdin);

#endif // ONLINE_JUDGE

BitSet::init();

int T;

cin >> T;

while (T --) {

scanf("%s", s);

int n = strlen(s), total = n * 2 - 1;

hsh.init(s, n);

for (int i = 0; i < n; i ++) revs[i] = s[n - i - 1];

hshrev.init(revs, n);

for (int i = 0; i < total; i ++) {

int L = i / 2, R = (i + 1) / 2;

int minlen = 0, maxlen = min(L + 1, n - R);

while (minlen < maxlen) {

int midlen = (minlen + maxlen + 1) >> 1;

int lpos = L - midlen + 1, rpos = R + midlen - 1;

if (hsh.get(lpos, L) == hshrev.get(n - rpos - 1, n - R - 1)) minlen = midlen;

else maxlen = midlen - 1;

}

F[i] = minlen;

}

fillchar(pre, 0);

fillchar(suf, 0);

pre[0] = suf[n - 1] = true;

BitSet bs1(n), bs2(n);

bs1.setval(0, 0, 1);

bs2.setval(0, 0, 1);

for (int i = 1; i < n; i ++) {

pre[i] = F[i] == i / 2 + 1;

if (pre[i]) bs1.setval(i, i, 1);

}

for (int i = n - 2; i >= 0; i --) {

suf[i] = F[i + n - 1] == (n - i + 1) / 2;

if (suf[i]) bs2.setval(n - i - 1, n - i - 1, 1);

}

bool ok = false;

for (int i = 0; i < total; i ++) {

int L = i / 2, R = (i + 1) / 2;

int len = F[i], lpos = L - len + 1, rpos = R + len - 1;

if (len == 0) continue;

BitSet buf, result, newbuf(n);

if (n - R >= L + 1) {

buf = bs2 >> (n - R - L - 1);

result = bs1 & buf;

newbuf.setval(max(0, lpos - 1), L - 1, 1);

}

if (L + 1 > n - R) {

buf = bs1 >> (L + 1 - n + R);

result = buf & bs2;

newbuf.setval(max(0, n - rpos - 2), n - R - 2, 1);

}

newbuf = newbuf & result;

if (!newbuf.zero()) {

ok = true;

break;

}

puts(ok? "Yes" : "No");

}

return 0;

}

/* ******************************************************************************** */

[hdu5340]二分，枚举，二进制压位加速的更多相关文章

压位加速-poj-2443-Set Operation
题目链接: http://poj.org/problem?id=2443 题目意思: 有n个集合(n<=1000),每个集合有m个数ai(m<=10000,1=<ai<=100 ...
POJ 2443 Set Operation（压位加速）
http://poj.org/problem?id=2443 题意: 有1000个集合,每个集合有至多10000个数,之后输入多个询问,判断询问的两个数是否位于同一个集合. 思路: 位运算...很强大 ...
HDU- 3605 - Escape 最大流 + 二进制压位
HDU - 3605 : acm.hdu.edu.cn/showproblem.php?pid=3605 题目: 有1e5的的人,小于10个的星球,每个星球都有容量,每个人也有适合的星球和不适合的星球 ...
[BZOJ5109][LOJ #6252][P4061][CodePlus 2017 11月赛]大吉大利，今晚吃鸡！(最短路+拓扑排序+传递闭包+map+bitset(hash+压位))
5109: [CodePlus 2017]大吉大利,晚上吃鸡! Time Limit: 30 Sec Memory Limit: 1024 MBSubmit: 107 Solved: 57[Sub ...
[YNOI2017][bzoj4811][luogu3613] 由乃的OJ/睡觉困难综合症 [压位+树链剖分+线段树]
题面 BZOJ题面,比较不清晰 Luogu题面,写的比较清楚思路原题目我们先看这道题的原题目NOI2014起床困难综合症的确就是上树的带修改版本那么我们先来解决这个原版的序列上单次询问二进 ...
【C#进阶系列】15 枚举类型和位标志
实际上本章就只讲枚举类型,因为位标志本来就可以当做一个特殊的枚举类型. 关于枚举类型枚举类型是一种消灭魔法数字的好方法,使程序更容易编写,阅读和维护. 枚举类型是值类型,然而有别于其它值类型,枚举类 ...
codevs 3119 高精度练习之大整数开根 (各种高精+压位)
/* codevs 3119 高精度练习之大整数开根 (各种高精+压位) 二分答案然后高精判重打了一个多小时..... 最后还超时了...压位就好了测试点#1.in 结果:AC 内存使用量: 2 ...
UOJ #314. 【NOI2017】整数 | 线段树压位
题目链接 UOJ 134 题解可爱的电音之王松松松出的题--好妙啊. 首先想一个朴素的做法! 把当前的整数的二进制当作01序列用线段树维护一下(序列的第i位就是整数中位权为\(2^k\)的那一位). ...
【NOI】2017 整数（BZOJ 4942，LOJ2302）压位+线段树
[题目]#2302. 「NOI2017」整数 [题意]有一个整数x,一开始为0.n次操作,加上a*2^b,或询问2^k位是0或1.\(n \leq 10^6,|a| \leq 10^9,0 \leq ...

随机推荐

不同目录有同名proto文件情况下，protoc生成.cc/.h
首先先参考一下别人的博客,看完了,看懂了,再回过头来看我下面说的情况. 链接 https://blog.csdn.net/CAir2/article/details/78201572 但是这个也就是基 ...
CTFHub web技能树 RCE
一个简单的ping,还没有过滤,源码也给出来了 ls一下 127.0.0.1 & ls 有一个可疑的php文件,,,但是直接访问和 cat 都出不来... 试了几下反弹shell,没成功... ...
面试题56 - I. 数组中数字出现的次数
面试题56 - I. 数组中数字出现的次数一个整型数组 nums 里除两个数字之外,其他数字都出现了两次.请写程序找出这两个只出现一次的数字.要求时间复杂度是O(n),空间复杂度是O(1). 示例 ...
thinkphp5--多文件入口设置
来源:http://www.cnblogs.com/walblog/p/8035426.html 今天在用tp5做项目的时候发现,前台是可以绑定默认到index模块的,但是后台不好弄,于是查了一下手册 ...
Linux安全实验缓冲区溢出
缓冲区溢出实验: 缓冲区溢出是指程序试图向缓冲区写入超出预分配固定长度数据的情况.这一漏洞可以被恶意用户利用来改变程序的流控制,甚至执行代码的任意片段.这一漏洞的出现是由于数据缓冲器和返回地址的暂时关 ...
MySQL系列（三）
本章内容: 视图.增/删/改/查触发器.增/删/改/查存储过程.增/删/改/查存储过程三种传参,pymysql 怎么用? 函数.增/删/改/查/return值内置函数事务 1.1视图视图是 ...
Libra白皮书解读
文章目录 Libra简介 Libra区块链 Libra货币和存储 Libra协会 Libra简介 Libra是facebook发起的一个区块链项目,其使命是建立一套简单的.无国界的货币和为数十亿人服务 ...
这个linux命令能让时光倒流！你不知道的date隐藏用法
文章每周持续更新,各位的「三连」是对我最大的肯定.可以微信搜索公众号「后端技术学堂」第一时间阅读(一般比博客早更新一到两篇) 今天给项目写了个脚本需要获取前一天的时间,本来先获取今天的然后减一下, ...
[mysql]linux mysql 读写分离
[mysql]linux mysql 读写分离作者:flymaster qq:908601287 blog:http://www.cnblogs.com/flymaster500/ 1.简介当今M ...
JS编程建议——11：慎重使用伪数组
建议11:慎重使用伪数组JavaScript没有真正的数组,因此typeof运算符不能辨别数组和对象.伪数组在JavaScript中有很高的易用性,程序员不用给它设置维度,而且永远不用担心产生越界错误 ...

[hdu5340]二分，枚举，二进制压位加速

[hdu5340]二分，枚举，二进制压位加速的更多相关文章

随机推荐

热门专题