热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

hdu5751Eades

题意:对于整数序列$A[1n]$定义$f(l,r)$为区间$[l,r]$内等于区间最大值元素的个数,定义$z[i]$为所有满足$f(l,r)i$的区间总数。对于所有的$1\l

题意:对于整数序列$A[1...n]$定义$f(l, r)$为区间$[l, r]$内等于区间最大值元素的个数,定义$z[i]$为所有满足$f(l, r)=i$的区间总数。对于所有的$1 \leq i \leq n$,计算$z[i]$。

分析:考虑由大往小枚举最大值,对于某一最大值为$M$的区间$[l, r)$,满足$a[p_i]=M$的元素将区间切割为若干子区间,那么这些子区间对长度的积对答案的某一项有等值的贡献,暴力枚举需要$O(n^2)$的时间,整体考虑那些对答案某一项有贡献的子区间对的积,它们满足卷积的性质。因此只需将长度序列与其反序列作类似多项式乘法的fft,即可将时间优化为$O(nlog(n))$。子区间递归处理即可。代码如下:

技术分享技术分享
  1 #include 
  2 #include 
  3 #include 
  4 #include <string>
  5 #include 
  6 #include 
  7 #include <set>
  8 #include 
  9 #include 
 10 #include 
 11 #include 
 12 #include 
 13 #pragma comment(linker, "/STACK:102400000,102400000")
 14 #define max(a, b) ((a) > (b) ? (a) : (b))
 15 #define min(a, b) ((a) <(b) ? (a) : (b))
 16 #define mp std :: make_pair
 17 #define st first
 18 #define nd second
 19 #define keyn (root->ch[1]->ch[0])
 20 #define lson (u <<1)
 21 #define rson (u <<1 | 1)
 22 #define pii std :: pair
 23 #define pll pair
 24 #define pb push_back
 25 #define type(x) __typeof(x.begin())
 26 #define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
 27 #define FOR(i, s, t) for(int i = (s); i <= (t); i++)
 28 #define ROF(i, t, s) for(int i = (t); i >= (s); i--)
 29 #define dbg(x) std::cout < 30 #define dbg2(x, y) std::cout < 31 #define clr(x, i) memset(x, (i), sizeof(x))
 32 #define maximize(x, y) x = max((x), (y))
 33 #define minimize(x, y) x = min((x), (y))
 34 using namespace std;
 35 typedef long long ll;
 36 const int int_inf = 0x3f3f3f3f;
 37 const ll ll_inf = 0x3f3f3f3f3f3f3f3f;
 38 const int INT_INF = (int)((1ll <<31) - 1);
 39 const double double_inf = 1e30;
 40 const double eps = 1e-14;
 41 typedef unsigned long long ul;
 42 typedef unsigned int ui;
 43 inline int readint(){
 44     int x;
 45     scanf("%d", &x);
 46     return x;
 47 }
 48 inline int readstr(char *s){
 49     scanf("%s", s);
 50     return strlen(s);
 51 }
 52 
 53 class cmpt{
 54 public:
 55     bool operator () (const int &x, const int &y) const{
 56         return x > y;
 57     }
 58 };
 59 
 60 int Rand(int x, int o){
 61     //if o set, return [1, x], else return [0, x - 1]
 62     if(!x) return 0;
 63     int tem = (int)((double)rand() / RAND_MAX * x) % x;
 64     return o ? tem + 1 : tem;
 65 }
 66 void data_gen(){
 67     srand(time(0));
 68     freopen("in.txt", "w", stdout);
 69     int kases = 20;
 70     printf("%d\n", kases);
 71     while(kases--){
 72         int sz = 6e4;
 73         printf("%d\n", sz);
 74         FOR(i, 1, sz) printf("%d ", Rand(sz, 1));
 75         printf("\n");
 76     }
 77 }
 78 
 79 struct cmpx{
 80     bool operator () (int x, int y) { return x > y; }
 81 };
 82 const int maxn = 6e4 + 10;
 83 int a[maxn];
 84 int n;
 85 struct Seg{
 86     int l, r, v;
 87 }seg[maxn <<2];
 88 void build(int u, int l, int r){
 89     seg[u].l = l, seg[u].r = r;
 90     if(seg[u].r - seg[u].l <2){
 91         seg[u].v = l;
 92         return;
 93     }
 94     int mid = (l + r) >> 1;
 95     build(lson, l, mid), build(rson, mid, r);
 96     if(a[seg[rson].v] > a[seg[lson].v]) seg[u].v = seg[rson].v;
 97     else seg[u].v = seg[lson].v;
 98 }
 99 int query(int u, int l, int r){
100     if(seg[u].l == l && seg[u].r == r) return seg[u].v;
101     int mid = (seg[u].l + seg[u].r) >> 1;
102     if(r <= mid) return query(lson, l, r);
103     else if(l >= mid) return query(rson, l, r);
104     int lhs = query(lson, l, mid), rhs = query(rson, mid, r);
105     if(a[rhs] > a[lhs]) return rhs;
106     return lhs;
107 }
108 int maxi;
109 vector<int> pos[maxn];
110 int idx[maxn];
111 void init(){
112     maxi = -1;
113     FOR(i, 1, n) maximize(maxi, a[i]);
114     FOR(i, 1, maxi) pos[i].clear();
115     FOR(i, 1, n){
116         int sz = pos[a[i]].size();
117         idx[i] = sz;
118         pos[a[i]].pb(i);
119     }
120 }
121 ll z[maxn];
122 ll c[maxn], d[maxn], e[maxn <<1];
123 int k;
124 const double PI = 2 * asin(1.);
125 struct Complex{
126     double x, y;
127     Complex(double x = 0, double y = 0) : x(x), y(y) {}
128 };
129 Complex operator + (const Complex &lhs, const Complex &rhs){
130     return Complex(lhs.x + rhs.x, lhs.y + rhs.y);
131 }
132 Complex operator - (const Complex &lhs, const Complex &rhs){
133     return Complex(lhs.x - rhs.x, lhs.y - rhs.y);
134 }
135 Complex operator * (const Complex &lhs, const Complex &rhs){
136     double tl = lhs.x * rhs.x, tr = lhs.y * rhs.y, tt = (lhs.x + lhs.y) * (rhs.x + rhs.y);
137     return Complex(lhs.x * rhs.x - lhs.y * rhs.y, lhs.x * rhs.y + lhs.y * rhs.x);
138 }
139 Complex w[2][maxn <<2], x[maxn <<2], y[maxn <<2];
140 
141 void fft(Complex x[], int k, int v){
142     int i, j, l;
143     Complex tem;
144     for(i = j = 0; i ){
145         if(i > j) tem = x[i], x[i] = x[j], x[j] = tem;
146         for(l = k >> 1; (j ^= l) >= 1) ;
147     }
148     for(i = 2; i <= k; i <<= 1) for(j = 0; j for(l = 0; l > 1; l++){
149         tem = x[j + l + (i >> 1)] * w[v][k / i * l];
150         x[j + l + (i >> 1)] = x[j + l] - tem;
151         x[j + l] = x[j + l] + tem;
152     }
153 }
154 int tot;
155 void solve(int l, int r){
156     if(l >= r) return;
157     if(r - l == 1){
158         ++z[1];
159         return;
160     }
161     int p = query(1, l, r);
162     int tem = idx[p];
163     int sz = pos[a[p]].size();
164     k = 0;
165     c[k++] = p - l + 1;
166     while(tem  + 1 1] 1] - pos[a[p]][tem], ++tem;
167     c[k++] = r - pos[a[p]][tem];
168     ROF(i, k - 1, 0) d[i] = c[k - 1 - i];
169     int len;
170     for(len = 1; len <(k <<1); len <<= 1) ;
171     FOR(i, 0, len) w[1][len - i] = w[0][i] = Complex(cos(PI * 2 * i / len), sin(PI * 2 * i / len));
172     FOR(i, 0, k - 1) x[i] = Complex(c[i], 0);
173     FOR(i, k, len - 1) x[i] = Complex(0, 0);
174     fft(x, len, 0);
175     FOR(i, 0, k - 1) y[i] = Complex(d[i], 0);
176     FOR(i, k, len - 1) y[i] = Complex(0, 0);
177     fft(y, len, 0);
178     FOR(i, 0, len - 1) x[i] = x[i] * y[i];
179     fft(x, len, 1);
180     FOR(i, 0, 2 * k - 2) e[i] = (ll)(x[i].x / len + .5);
181     FOR(i, 0, k - 2) z[k - 1 - i] += e[i];
182     tem = idx[p];
183     solve(l, p);
184     while(tem + 1 1] 1, pos[a[p]][tem + 1]), ++tem;
185     solve(pos[a[p]][tem] + 1, r);
186 }
187 int main(){
188     //data_gen(); return 0;
189     //C(); return 0;
190     int debug = 0;
191     if(debug) freopen("in.txt", "r", stdin);
192     //freopen("out.txt", "w", stdout);
193     int T = readint();
194     while(T--){
195         n = readint();
196         FOR(i, 1, n) a[i] = readint();
197         build(1, 1, n + 1);
198         init();
199         clr(z, 0);
200         tot = 0;
201         solve(1, n + 1);
202         ll ans = 0;
203         FOR(i, 1, n) ans += z[i] ^ i;
204         printf("%lld\n", ans);
205     }
206     return 0;
207 }
code:

hdu 5751 Eades


推荐阅读
  • 本文详细介绍了Linux中进程控制块PCBtask_struct结构体的结构和作用,包括进程状态、进程号、待处理信号、进程地址空间、调度标志、锁深度、基本时间片、调度策略以及内存管理信息等方面的内容。阅读本文可以更加深入地了解Linux进程管理的原理和机制。 ... [详细]
  • 本文介绍了lua语言中闭包的特性及其在模式匹配、日期处理、编译和模块化等方面的应用。lua中的闭包是严格遵循词法定界的第一类值,函数可以作为变量自由传递,也可以作为参数传递给其他函数。这些特性使得lua语言具有极大的灵活性,为程序开发带来了便利。 ... [详细]
  • 本文介绍了使用Java实现大数乘法的分治算法,包括输入数据的处理、普通大数乘法的结果和Karatsuba大数乘法的结果。通过改变long类型可以适应不同范围的大数乘法计算。 ... [详细]
  • HDU 2372 El Dorado(DP)的最长上升子序列长度求解方法
    本文介绍了解决HDU 2372 El Dorado问题的一种动态规划方法,通过循环k的方式求解最长上升子序列的长度。具体实现过程包括初始化dp数组、读取数列、计算最长上升子序列长度等步骤。 ... [详细]
  • 本文讨论了如何优化解决hdu 1003 java题目的动态规划方法,通过分析加法规则和最大和的性质,提出了一种优化的思路。具体方法是,当从1加到n为负时,即sum(1,n)sum(n,s),可以继续加法计算。同时,还考虑了两种特殊情况:都是负数的情况和有0的情况。最后,通过使用Scanner类来获取输入数据。 ... [详细]
  • 本文介绍了C#中数据集DataSet对象的使用及相关方法详解,包括DataSet对象的概述、与数据关系对象的互联、Rows集合和Columns集合的组成,以及DataSet对象常用的方法之一——Merge方法的使用。通过本文的阅读,读者可以了解到DataSet对象在C#中的重要性和使用方法。 ... [详细]
  • 本文介绍了OC学习笔记中的@property和@synthesize,包括属性的定义和合成的使用方法。通过示例代码详细讲解了@property和@synthesize的作用和用法。 ... [详细]
  • 在说Hibernate映射前,我们先来了解下对象关系映射ORM。ORM的实现思想就是将关系数据库中表的数据映射成对象,以对象的形式展现。这样开发人员就可以把对数据库的操作转化为对 ... [详细]
  • 1,关于死锁的理解死锁,我们可以简单的理解为是两个线程同时使用同一资源,两个线程又得不到相应的资源而造成永无相互等待的情况。 2,模拟死锁背景介绍:我们创建一个朋友 ... [详细]
  • 《数据结构》学习笔记3——串匹配算法性能评估
    本文主要讨论串匹配算法的性能评估,包括模式匹配、字符种类数量、算法复杂度等内容。通过借助C++中的头文件和库,可以实现对串的匹配操作。其中蛮力算法的复杂度为O(m*n),通过随机取出长度为m的子串作为模式P,在文本T中进行匹配,统计平均复杂度。对于成功和失败的匹配分别进行测试,分析其平均复杂度。详情请参考相关学习资源。 ... [详细]
  • 动态规划算法的基本步骤及最长递增子序列问题详解
    本文详细介绍了动态规划算法的基本步骤,包括划分阶段、选择状态、决策和状态转移方程,并以最长递增子序列问题为例进行了详细解析。动态规划算法的有效性依赖于问题本身所具有的最优子结构性质和子问题重叠性质。通过将子问题的解保存在一个表中,在以后尽可能多地利用这些子问题的解,从而提高算法的效率。 ... [详细]
  • 高质量SQL书写的30条建议
    本文提供了30条关于优化SQL的建议,包括避免使用select *,使用具体字段,以及使用limit 1等。这些建议是基于实际开发经验总结出来的,旨在帮助读者优化SQL查询。 ... [详细]
  • 本文介绍了指针的概念以及在函数调用时使用指针作为参数的情况。指针存放的是变量的地址,通过指针可以修改指针所指的变量的值。然而,如果想要修改指针的指向,就需要使用指针的引用。文章还通过一个简单的示例代码解释了指针的引用的使用方法,并思考了在修改指针的指向后,取指针的输出结果。 ... [详细]
  • 猜字母游戏
    猜字母游戏猜字母游戏——设计数据结构猜字母游戏——设计程序结构猜字母游戏——实现字母生成方法猜字母游戏——实现字母检测方法猜字母游戏——实现主方法1猜字母游戏——设计数据结构1.1 ... [详细]
  • CentOS 7部署KVM虚拟化环境之一架构介绍
    本文介绍了CentOS 7部署KVM虚拟化环境的架构,详细解释了虚拟化技术的概念和原理,包括全虚拟化和半虚拟化。同时介绍了虚拟机的概念和虚拟化软件的作用。 ... [详细]
author-avatar
嘉娜杰_877
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有