BZOJ 3236 AHOI 2013 作业 莫队算法

最新推荐文章于 2019-05-07 08:53:00 发布
最新推荐文章于 2019-05-07 08:53:00 发布
阅读量1.4k 收藏
点赞数
分类专栏： BZOJ 文章标签： BZOJ AHOI 2013 莫队算法 分块
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangyuze831/article/details/41245961
版权

题目大意：给出一些数，问在一个区间中不同的数值有多少种，和在一个区间中不同的数值有多少个。


思路：由于没有修改，所以就想到了莫队算法。然后我写了5K+的曼哈顿距离最小生成树，然后果断T了。(100s的时限啊,刷status都要刷疯了..,结果最后加了手写读入也没能A)。后来果断放弃，写了分块版的莫队算法。84sAC。。。这题卡的。。貌似莫队并不是正解。

其实用分块来写莫队就很简单了。只需要将所有询问的区间排序，左端点所在块作为第一键值，右端点作为第二季键值排序，之后就可以转移了。理论上来时还是曼哈顿距离最小生成树比较快，但是常数实在是太大，随处可见的pair，sort。。还不太好写。。唉。。时代的眼泪。。。


CODE(84816AC)：


#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define MAX 1100010
using namespace std;

struct Ask{
	int x,y,_id;
	int block;
	int a,b;
	
	bool operator <(const Ask &a)const {
		if(block == a.block)	return y < a.y;
		return block < a.block;
	}
	void Read(int p) {
		scanf("%d%d%d%d",&x,&y,&a,&b);
		_id = p;
	}
}ask[MAX];

int cnt,asks;
pair<int,int *> xx[MAX << 1];
int src[MAX];

int t;
int fenwick[MAX << 1],_fenwick[MAX];
int num[MAX];
pair<int,int> ans[MAX];

inline int GetSum(int fenwick[],int x)
{
	int re = 0;
	for(; x; x -= x&-x)
		re += fenwick[x];
	return re;		
}

inline void Fix(int fenwick[],int x,int c)
{
	for(; x <= t; x += x&-x)
		fenwick[x] += c;
}

int main()
{
	cin >> cnt >> asks;
	int temp = 0;
	for(int i = 1; i <= cnt; ++i)
		scanf("%d",&xx[++temp].first),xx[temp].second = &src[i];
	for(int i = 1; i <= asks; ++i) {
		ask[i].Read(i);
		xx[++temp] = make_pair(ask[i].a,&ask[i].a);
		xx[++temp] = make_pair(ask[i].b,&ask[i].b);
	}
	sort(xx + 1,xx + temp + 1);
	for(int i = 1; i <= temp; ++i) {
		if(!t || xx[i].first != xx[i - 1].first)
			++t;
		*xx[i].second = t;
	}
	int block = static_cast<int>(sqrt(cnt));
	for(int i = 1; i <= asks; ++i)
		ask[i].block = ask[i].x / block;
	sort(ask + 1,ask + asks + 1);
	int l = 1,r = 0;
	for(int x = 1; x <= asks; ++x) {
		while(r < ask[x].y) {
			++num[src[++r]];
			Fix(fenwick,src[r],1);
			if(num[src[r]] == 1)	Fix(_fenwick,src[r],1);
		}
		while(l > ask[x].x) {
			++num[src[--l]];
			Fix(fenwick,src[l],1);
			if(num[src[l]] == 1)	Fix(_fenwick,src[l],1);
		}
		while(r > ask[x].y) {
			--num[src[r]];
			Fix(fenwick,src[r],-1);
			if(!num[src[r]])	Fix(_fenwick,src[r],-1);
			--r;
		}
		while(l < ask[x].x) {
			--num[src[l]];
			Fix(fenwick,src[l],-1);
			if(!num[src[l]])	Fix(_fenwick,src[l],-1);
			++l;
		}
		int p = ask[x]._id;
		ans[p].first = GetSum(fenwick,ask[x].b) - GetSum(fenwick,ask[x].a - 1);
		ans[p].second = GetSum(_fenwick,ask[x].b) - GetSum(_fenwick,ask[x].a - 1);
	}
	for(int i = 1; i <= asks; ++i)
		printf("%d %d\n",ans[i].first,ans[i].second);
	return 0;
}

CODE(TLE)： 


#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define MAX 1100010
#define INF 0x3f3f3f3f
using namespace std;
 
inline int GetInt()
{
    int res=0;
    char t=getchar();
    for (;t>'9'||t<'0';t=getchar());
    for (;t>='0'&&t<='9';t=getchar()) res=res*10+t-'0';
    return res;
}
 
struct Ask{
    int x,y,_id;
    int a,b;
     
    bool operator <(const Ask &a)const {
        if(x == a.x)    return y < a.y;
        return x < a.x;
    }
    void Read() {
        x = GetInt();
        y = GetInt();
        a = GetInt();
        b = GetInt();
    }
}ask[MAX];
 
struct Edge{
    int x,y,length;
     
    Edge(int _,int __,int ___):x(_),y(__),length(___) {}
    Edge() {}
    bool operator <(const Edge &a)const {
        return length < a.length;
    }
}edge[MAX << 3];
 
int cnt,asks;
int src[MAX];
 
int y_x[MAX],t,gt,edges;
pair<int,int *> xx[MAX << 1];
int fenwick[MAX << 1],_fenwick[MAX];
 
int father[MAX];
 
int head[MAX],total;
int next[MAX << 1],aim[MAX << 1];
 
int num[MAX];
pair<int,int> ans[MAX];
 
inline int CalcM(const Ask &a,const Ask &b)
{
    return abs(a.x - b.x) + abs(a.y - b.y);
}
 
inline int GetPos(int x)
{
    int re = 0;
    for(; x <= t; x += x&-x)
        if(ask[fenwick[x]].x + ask[fenwick[x]].y < ask[re].x + ask[re].y)
            re = fenwick[x];
    return re;
}
 
inline void Fix(int x,int pos)
{
    for(; x; x -= x&-x)
        if(ask[fenwick[x]].x + ask[fenwick[x]].y > ask[pos].x + ask[pos].y)
            fenwick[x] = pos;
}
 
void MakeGraph()
{
    for(int dir = 1; dir <= 4; ++dir) {
        if(dir == 2 || dir == 4)
            for(int i = 1; i <= asks; ++i)
                swap(ask[i].x,ask[i].y);
        if(dir == 3)
            for(int i = 1; i <= asks; ++i)
                ask[i].y *= -1;
        sort(ask + 1,ask + asks + 1);
        for(int i = 1; i <= asks; ++i)
            xx[i] = make_pair(ask[i].y - ask[i].x,&y_x[i]);
        sort(xx + 1,xx + asks + 1);
        t = 0;
        for(int i = 1; i <= asks; ++i) {
            if(!t || xx[i].first != xx[i - 1].first)
                ++t;
            *xx[i].second = t;
        }
        memset(fenwick,0,sizeof(fenwick));
        for(int i = asks; i; --i) {
            int temp = GetPos(y_x[i]);
            if(temp)
                edge[++edges] = Edge(ask[temp]._id,ask[i]._id,CalcM(ask[temp],ask[i]));
            Fix(y_x[i],i);
        }
    }
    for(int i = 1; i <= asks; ++i)
        ask[i].x *= -1;
}
 
int Find(int x)
{
    if(father[x] == x)  return x;
    return father[x] = Find(father[x]);
}
 
inline void Add(int x,int y)
{
    next[++total] = head[x];
    aim[total] = y;
    head[x] = total;
}
 
void MST()
{
    sort(edge + 1,edge + edges + 1);
    for(int i = 1; i <= edges; ++i) {
        int fx = Find(edge[i].x);
        int fy = Find(edge[i].y);
        if(fx != fy) {
            father[fx] = fy;
            Add(fx,fy),Add(fy,fx);
        }
    }
}
 
inline int GetSum(int fenwick[],int x)
{
    int re = 0;
    for(; x; x -= x&-x)
        re += fenwick[x];
    return re;      
}
 
inline void Fix(int fenwick[],int x,int c)
{
    for(; x <= gt; x += x&-x)
        fenwick[x] += c;
}
 
void DFS(int x,int last)
{
    static int l = 1,r = 0;
     
    while(r < ask[x].y) {
        ++num[src[++r]];
        Fix(fenwick,src[r],1);
        if(num[src[r]] == 1)    Fix(_fenwick,src[r],1);
    }
    while(l > ask[x].x) {
        ++num[src[--l]];
        Fix(fenwick,src[l],1);
        if(num[src[l]] == 1)    Fix(_fenwick,src[l],1);
    }
    while(r > ask[x].y) {
        --num[src[r]];
        Fix(fenwick,src[r],-1);
        if(!num[src[r]])    Fix(_fenwick,src[r],-1);
        --r;
    }
    while(l < ask[x].x) {
        --num[src[l]];
        Fix(fenwick,src[l],-1);
        if(!num[src[l]])    Fix(_fenwick,src[l],-1);
        ++l;
    }
     
    int p = ask[x]._id;
    ans[p].first = GetSum(fenwick,ask[x].b) - GetSum(fenwick,ask[x].a - 1);
    ans[p].second = GetSum(_fenwick,ask[x].b) - GetSum(_fenwick,ask[x].a - 1);
     
    for(int i = head[x]; i; i = next[i]) {
        if(aim[i] == last)  continue;
        DFS(aim[i],x);
     
        while(r < ask[x].y) {
            ++num[src[++r]];
            Fix(fenwick,src[r],1);
            if(num[src[r]] == 1)    Fix(_fenwick,src[r],1);
        }
        while(l > ask[x].x) {
            ++num[src[--l]];
            Fix(fenwick,src[l],1);
            if(num[src[l]] == 1)    Fix(_fenwick,src[l],1);
        }
        while(r > ask[x].y) {
            --num[src[r]];
            Fix(fenwick,src[r],-1);
            if(!num[src[r]])    Fix(_fenwick,src[r],-1);
            --r;
        }
        while(l < ask[x].x) {
            --num[src[l]];
            Fix(fenwick,src[l],-1);
            if(!num[src[l]])    Fix(_fenwick,src[l],-1);
            ++l;
        }
    }
}
 
int main()
{
    ask[0].x = ask[0].y = INF;
    cnt = GetInt();
    asks = GetInt();
    int temp = 0;
    for(int i = 1; i <= cnt; ++i) {
        xx[++temp].first = GetInt();
        xx[temp].second = &src[i];  
    }
    for(int i = 1; i <= asks; ++i) {
        ask[i].Read();
        xx[++temp] = make_pair(ask[i].a,&ask[i].a);
        xx[++temp] = make_pair(ask[i].b,&ask[i].b);
        ask[i]._id = i;
        father[i] = i;
    }
    sort(xx + 1,xx + temp + 1);
    for(int i = 1; i <= temp; ++i) {
        if(!gt || xx[i].first != xx[i - 1].first)
            ++gt;
        *xx[i].second = gt;
    }
    MakeGraph();
    MST();
    memset(fenwick,0,sizeof(fenwick));
    DFS(1,0);
    for(int i = 1; i <= asks; ++i)
        printf("%d %d\n",ans[i].first,ans[i].second);
    return 0;
}


16bit戦争
关注
专栏目录
BZOJ 3233 Ahoi2013 找硬币 动态规划
世界
06-09 1577
题目大意：给定nn个数，求一种混合进制使得每个数各个位之和之和最小 令fif_i表示表示最大硬币面值为ii时零头部分(即ak mod ia_k\ mod\ i部分)的最小硬币数 那么有转移方程：fj=min{fi+∑nk=1⌊ak mod ji⌋}(i|j)f_j=min\{f_i+\sum_{k=1}^n\lfloor\frac{a_k\ mod\ j}i\rfloor\}(i|j) 然后a
【BZOJ2823】【AHOI2012】信号塔 最小圆覆盖 计算几何
辗转山河弋流歌
06-23 2280
题解之前： 首先最小圆覆盖虽然有三层 forfor 循环，但是它是期望 O(n)O(n) 的。什么？你问我为啥？那我只能呵呵了，50W的 O(n3)O(n^3) 高速跑过。 后交的是不求凸包直接跑的，先交的是求了凸包再跑的。。并没有什么差距。 题解： 这道题我们可以先写一份求凸包来缩减点的规模，如果点是随机生成的，那么期望有不到100个点在凸包上，然后就可以乱搞了（其实毛用没有23
[AHOI2013]作业
weixin_34376986的博客
04-05 133
传送门 Description 给定了一个长度为\(n\)的数列和若干个询问，每个询问是关于数列的区间表示数列的第\(l\)个数到第\(r\)个数)，首先你要统计该区间内大于等于\(a\)，小于等于\(b\)的数的个数，其次是所有大于等于\(a\)，小于等于\(b\)的，且在该区间中出现过的数值的个数。 \(n,m \leq 10^5\) Solution 非常简单的莫队题目 追求...
BZOJ 3236: [Ahoi2013]作业【莫队+树状数组】
aiweiluan5095的博客
06-16 124
3236: [Ahoi2013]作业 【题目描述】 传送门 【题解】 莫队+树状数组，树状数组维护前缀和，这个做法有点笨，87秒勉强卡过。 代码如下 #include<cmath> #include<cstdio> #include<cctype> #include<algorithm>...
Ahoi2013 作业
weixin_34119545的博客
04-27 129
3236: [Ahoi2013]作业 Time Limit:100 SecMemory Limit:512 MB Description Input Output Sample Input 3 4 1 2 2 1 2 1 3 1 2 1 1 1 3 1 3 2 3 2 3 Sample Out...
bzoj 1406: [AHOI2007]密码箱 数学
beginend
10-22 354
题意在一次偶然的情况下，小可可得到了一个密码箱，听说里面藏着一份古代流传下来的藏宝图，只要能破解密码就能打开箱子，而箱子背面刻着的古代图标，就是对密码的提示。经过艰苦的破译，小可可发现，这些图标表示一个数以及这个数与密码的关系。假设这个数是n，密码为x，那么可以得到如下表述： 密码x大于等于0，且小于n，而x的平方除以n，得到的余数为1。 小可可知道满足上述条件的x可能不止一个，所以一定要把所有满足
【醒目】【业界偷懒】【Public】BZOJ题目一句话题解整理
热门推荐
CreationAugust is 14 years old forever
05-12 1万+
就当是复习一下自己做过的题,顺便提供一个简要题解给大家看. 做题时候实在想不出来看一下一句话题解,可以有一个提示的作用又不至于一下子知道了全部浪费了一道题吧.. 部分题目(如我A过得大部分奶牛题)是别人拿我的账号做的,不提供题解.已AC的题目(数学题均不提供分析过程,公式): 1000:A+B 1001:平面图最小割,转对偶图最短路 1002:矩阵树定理,也可以通过推矩阵的递推关系得到递推
【算法详解】LCA（最近公共祖先）
魃魈魁鬾魑魅魍魉的博客
02-17 656
定义： Lca（最近公共祖先） 指在一棵有根树中任意222个节点u,vu,vu,v最近的公共祖先。 如下图： 如右图，结点4，64，64，6的公共祖先有1、21、21、2，但最近的公共祖先是222，即Lca(4,6)=2Lca(4,6) = 2Lca(4,6)=2。 如何求得u,vu,vu,v的最近公共祖先呢？ 算法一：暴力 现在有一个最朴素的算法，暴力。 111.u，v中深度大的往上走，直到...
【树套树】【bzoj 3236】: [Ahoi2013]作业
willinglive
11-21 826
http://www.lydsy.com/JudgeOnline/problem.php?id=3236 开始b
3236: [Ahoi2013]作业
CRZbulabula的博客
02-01 895
3236: [Ahoi2013]作业 Time Limit: 100 Sec  Memory Limit: 512 MB Submit: 1009  Solved: 387 [Submit][Status][Discuss] Description Input Output Sample Input 3 4 1 2 2 1 2 1 3
[bzoj3236][AHOI2013]作业
不来也不去的一只失忆蝴蝶
11-10 609
题目大意多次询问[l,r]内权值在[a,b]的数量及种类数。分块数量随便做，我们思考种类数怎么做。 具体见gty的二逼妹子序列题解#include<cstdio> #include<algorithm> #include<cmath> #define fo(i,a,b) for(i=a;i<=b;i++) using namespace std; const int maxn=100000+10,
P4396 [AHOI2013]作业
weixin_33982670的博客
05-07 95
思路 因为每次a和b不相同 用莫队+分块或者莫队+树状数组即可维护 不过分块单点修改是O(1)的，更优 我用树状数组维护了一下，只能开O2通过 代码 #include <cstdio> #include <algorithm> #include <cstring> #include <cmath> using namespace std; struc...
【洛谷】P4396 [AHOI2013]作业
Jerry_wang119的博客
10-07 395
分块+莫队的好题   Get 思想：对于一类涉及值域和序列的问题（线段树和主席树不可做的时候），一般可以考虑对序列莫队，对值域分块   利用莫队求出某个区间里面值为x的个数sum，值在某一块的数的个数num，以及值在某一块的不同的数的个数change   对于序列普通莫队   对于每一个询问每一次莫队结束之后统计答案的时候分块统计，值域在一整块加上change，不整块的直接暴力fo...
bzoj 3236: [Ahoi2013]作业 （莫队+分块）
clover_hxy的博客
02-21 1108
3236: [Ahoi2013]作业 Time Limit: 100 Sec  Memory Limit: 512 MB Submit: 1547  Solved: 635 [Submit][Status][Discuss] Description Input Output Sample Input 3 4 1 2 2 1 2 1 3
[Ahoi2013]作业 解题报告
TA
04-22 1172
很久以前用奇葩做法搞的题。。现在补个解题报告。传统做法： 考虑莫队，就需要我们设计一个O(1)O(1)插入，O(n√)O(\sqrt n)查询的数据结构，显然就需要对权值分块，记每个数出现次数和每个块两问的答案（或者第一问另写个主席树也可以，我比较懒）。莫队的块就分成nm√n\over \sqrt m块。时间复杂度O(mn√+nm−−√)O(m\sqrt n+n\sqrt m)。非常好写，跑的飞快
云计算与ACM算法：莫队与字符串处理模板详解
章节8.7则聚焦于莫队（莫尔投票算法），这是一种在离线情况下处理区间查询问题的有效算法，特别适用于那些静态数据的问题。通过一个具体的例子，BZOJ 2038：[2009 国家集训队] 小Z的袜子，它描述了如何根据袜子的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值