hdu3874Necklace(线段树或者BIT + 离线处理)

最新推荐文章于 2019-07-17 20:50:45 发布
最新推荐文章于 2019-07-17 20:50:45 发布
阅读量1k 收藏 1
点赞数
分类专栏： # 数据结构 # 线段树 文章标签： 线段树 BIT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ophunter_lcm/article/details/9220695
版权

->题目请戳这里<-

题目大意：给n个数，求任意区间不相同数字之和。

题目分析：n个数是给定的，不会变了，区间也是给定的。由于要求任意区间不重复数字之和，那就和这道super mario非常类似了，我们可以离线处理所有询问。由于要求不重复数字之和，我们把询问区间按右断点排序，这样从左往右扫描数列，如果以前没有出现的数字，直接插入，如果出现了，将这个数字上次出现的位置删去，在当前位置重新插入这个数。如果扫描的位置大于当前要查询的区间右端点，处理询问。由于所有要查询区间已按右端点排序，所以我们保证所有重复的数字也在靠右的地方插入，而每个重复的数字只插入了一次，所以可以保证所求区间数字和不重复。由于给定数字不超过1000000，所以直接开大数组搞，如果数字再大的话，就要哈希了。我的线段树跑了3000ms+，由于这题只要求区间和，所以BIT才是更好的选择，看了一下ranklist，好像都在1000ms+，说明这题的后台暑假还算给力啊哈哈。

线段树代码：

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N = 1000005;
const int NN = 50005;
typedef __int64 ll;
int hash[N];
int n,m;
int lcm[NN];
ll tree[NN<<2];
struct node
{
    int l,r,id;
}ask[NN<<2];
ll ans[NN<<2];

int cmp(struct node a,struct node b)
{
    if(a.r != b.r)
        return a.r < b.r;
    else
        return a.l < b.l;
}

void build(int num,int s,int e)
{
    tree[num] = 0;
    if(s == e)
        return;
    int mid = (s + e)>>1;
    build(num<<1,s,mid);
    build(num<<1|1,mid + 1,e);
}

void insert(int num,int s,int e,int pos,int add)
{
    if(s == e)
    {
        tree[num] += add;
        return;
    }
    int mid = (s + e)>>1;
    if(pos <= mid)
        insert(num<<1,s,mid,pos,add);
    else
        insert(num<<1|1,mid + 1,e,pos,add);
    tree[num] = tree[num<<1] + tree[num<<1|1];
}

ll query(int num,int s,int e,int l,int r)
{
    if(s == l && r == e)
        return tree[num];
    int mid = (s + e)>>1;
    if(r <= mid)
        return query(num<<1,s,mid,l,r);
    else
    {
        if(l > mid)
            return query(num<<1|1,mid + 1,e,l,r);
        else
            return query(num<<1,s,mid,l,mid) + query(num<<1|1,mid + 1,e,mid + 1,r);
    }
}

int main()
{
    int i,t;
    scanf("%d",&t);
    while(t --)
    {
        scanf("%d",&n);
        memset(hash,-1,sizeof(hash));
        for(i = 1;i <= n;i ++)
            scanf("%d",&lcm[i]);
        scanf("%d",&m);
        for(i = 0;i < m;i ++)
        {
            scanf("%d%d",&ask[i].l,&ask[i].r);
            ask[i].id = i + 1;
        }
        sort(ask,ask + m,cmp);
        build(1,1,n);
        int j = 1;
        for(i = 0;i < m;)
        {
            if(j <= ask[i].r)
            {
                if(hash[lcm[j]] == -1)
                {
                    insert(1,1,n,j,lcm[j]);
                    hash[lcm[j]] = j;//记录位置
                }
                else//已经插过lcm[j]了
                {
                    insert(1,1,n,hash[lcm[j]],-lcm[j]);//删除
                    hash[lcm[j]] = j;//更新位置
                    insert(1,1,n,j,lcm[j]);
                }
                j ++;
            }
            else
            {
                ans[ask[i].id] = query(1,1,n,ask[i].l,ask[i].r);
                i ++;
            }
        }
        for(i = 1;i <= m;i ++)
            printf("%I64d\n",ans[i]);
    }
    return 0;
}
//3328MS	9380K

BIT代码： 

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N = 1000005;
const int NN = 50005;
typedef __int64 ll;
int hash[N];
int n,m;
int lcm[NN];
ll tree[NN<<2];
struct node
{
    int l,r,id;
}ask[NN<<2];
ll ans[NN<<2];

int cmp(struct node a,struct node b)
{
    if(a.r != b.r)
        return a.r < b.r;
    else
        return a.l < b.l;
}

void build(int num,int s,int e)
{
    memset(tree,0,sizeof(tree));
}

void insert(int num,int s,int e,int pos,int add)
{
    int x = pos;
    while(x <= e)
    {
        tree[x] += add;
        x += x&(-x);
    }
}

ll sum(int p)
{
    ll ssum = 0;
    while(p)
    {
        ssum += tree[p];
        p -= p&(-p);
    }
    return ssum;
}

ll query(int num,int s,int e,int l,int r)
{
    return sum(r) - sum(l - 1);
}

int main()
{
    int i,t;
    scanf("%d",&t);
    while(t --)
    {
        scanf("%d",&n);
        memset(hash,-1,sizeof(hash));
        for(i = 1;i <= n;i ++)
            scanf("%d",&lcm[i]);
        scanf("%d",&m);
        for(i = 0;i < m;i ++)
        {
            scanf("%d%d",&ask[i].l,&ask[i].r);
            ask[i].id = i + 1;
        }
        sort(ask,ask + m,cmp);
        build(1,1,n);
        int j = 1;
        for(i = 0;i < m;)
        {
            if(j <= ask[i].r)
            {
                if(hash[lcm[j]] == -1)
                {
                    insert(1,1,n,j,lcm[j]);
                    hash[lcm[j]] = j;//记录位置
                }
                else//已经插过lcm[j]了
                {
                    insert(1,1,n,hash[lcm[j]],-lcm[j]);//删除
                    hash[lcm[j]] = j;//更新位置
                    insert(1,1,n,j,lcm[j]);
                }
                j ++;
            }
            else
            {
                ans[ask[i].id] = query(1,1,n,ask[i].l,ask[i].r);
                i ++;
            }
        }
        for(i = 1;i <= m;i ++)
            printf("%I64d\n",ans[i]);
    }
    return 0;
}
//2453MS	9916K

好像也不是很快啊。。。囧。。好吧，我写挫了肯定。。。

但是如果这样的话。。。

#include <iostream>
#include<cstdio>
#include<cctype>
#include<cstring>
using namespace std;
const int N = 1000005;
const int NN = 50005;
typedef __int64 ll;
int hash[N];
int n,m;
int lcm[NN];
ll tree[NN<<2];
struct node
{
    int l,r,id;
}ask[NN<<2];
ll ans[NN<<2];

int cmp(struct node a,struct node b)
{
    if(a.r != b.r)
        return a.r < b.r;
    else
        return a.l < b.l;
}

void build(int num,int s,int e)
{
    memset(tree,0,sizeof(tree));
}

void insert(int num,int s,int e,int pos,int add)
{
    int x = pos;
    while(x <= e)
    {
        tree[x] += add;
        x += x&(-x);
    }
}

ll sum(int p)
{
    ll ssum = 0;
    while(p)
    {
        ssum += tree[p];
        p -= p&(-p);
    }
    return ssum;
}

ll query(int num,int s,int e,int l,int r)
{
    return sum(r) - sum(l - 1);
}

int nextint()
{
    char c;int ret;
    while(isspace(c = getchar()))
        ;
    ret = c - '0';
    while((c = getchar()) >= '0' && c <= '9')
        ret = ret * 10 + c - '0';
    return ret;
}

int main()
{
    int i,t;
    //scanf("%d",&t);
    t = nextint();
    while(t --)
    {
        //scanf("%d",&n);
        n = nextint();
        memset(hash,-1,sizeof(hash));
        for(i = 1;i <= n;i ++)
        {
            //scanf("%d",&lcm[i]);
            lcm[i] = nextint();
        }
        m = nextint();
        //scanf("%d",&m);
        for(i = 0;i < m;i ++)
        {
            ask[i].l = nextint();
            ask[i].r = nextint();
            //scanf("%d%d",&ask[i].l,&ask[i].r);
            ask[i].id = i + 1;
        }
        sort(ask,ask + m,cmp);
        build(1,1,n);
        int j = 1;
        for(i = 0;i < m;)
        {
            if(j <= ask[i].r)
            {
                if(hash[lcm[j]] == -1)
                {
                    insert(1,1,n,j,lcm[j]);
                    hash[lcm[j]] = j;//记录位置
                }
                else//已经插过lcm[j]了
                {
                    insert(1,1,n,hash[lcm[j]],-lcm[j]);//删除
                    hash[lcm[j]] = j;//更新位置
                    insert(1,1,n,j,lcm[j]);
                }
                j ++;
            }
            else
            {
                ans[ask[i].id] = query(1,1,n,ask[i].l,ask[i].r);
                i ++;
            }
        }
        for(i = 1;i <= m;i ++)
            printf("%I64d\n",ans[i]);
    }
    return 0;
}//1640MS	9912K

我擦，效率大涨啊啊啊啊，好神奇的字符串解析加速。。。

ophunter
关注
专栏目录
HDU3973——线段树+字符串哈希
行走天涯的豆沙包的博客
07-07 444
题解： 给我们n个单词，然后一个模式串，然后两种区间操作，一种是单点修改一个单词，一种是查询一个区间内是否是一个单词。 我们线段树维护区间哈希值。然后区间查询操作和区间。 #include <bits/stdc++.h> using namespace std; #define lson u<<1 #define rson u<<1|1 const int N=1e5+10,p=131; typedef unsigned long long ull; set<ull
hdu3874Necklace
I fight, so you don't have to
12-24 479
树状数组的题，求区间内不同的数的和，离线处理，有个小技巧，按照右边查询r排序，每次都将相同的数更新到最右边，这样每次查询就可以计算不同的数的和。 #include #include #include #include #include #define LL __int64 #pragma comment(linker,"/STACK:1024000000,1024000000") using
线段树 hdu3874 Necklace
qwb的博客
08-09 952
这题有两种方法，，一种是莫队算法，，感觉莫队算法是一眼就能看出来可以用的，，只是写起来也略有麻烦 另外一种就是线段树，话说这题线段树写起来超级爽不知道为何 首先询问需要离线，然后按照右区间从大到小排序 pre[i]表示上一个数字i出现的位置 然后从1开始枚举i到n，每一次在区间[pre[A[i]]+1,i]上利用线段树成段更新加上A[i] 因为pre[A[i]]是上一个数字出现的
hdu3874 Necklace 线段树端点更新
WJSZMRX
08-13 691
题目大意：给n个数，求任意区间不相同数字之和。 题目分析：n个数是给定的，不会变了，区间也是给定的。由于要求任意区间不重复数字之和，那就和这道super mario非常类似了，我们可以离线处理所有询问。由于要求不重复数字之和，我们把询问区间按右断点排序，这样从左往右扫描数列，如果以前没有出现的数字，直接插入，如果出现了，将这个数字上次出现的位置删去，在当前位置重新插入这个数。如果扫描的位置大
可持久化线段树（主席树）入门笔记
weixin_30246221的博客
02-20 189
何为可持久化线段树 　 我们通常建立的线段树是可以支持修改操作更新操作和查询操作的，却不支持保存你更改每个操作的历史版本。而可持久化线段树就是可以保存各个历史版本的线段树。 最朴素的保存各个历史版本的线段树就是将每次更改后的线段树都保存下来，但是这样操作有个很严重的问题：太吃空间了。你n次修改就要保存n+1棵树，数据量一大，你所需要的空间就直线上升。 那有没有什么好解决...
HDU题型分类
Xylon的博客
12-02 834
基础题：1000、1001、1004、1005、1008、1012、1013、1014、1017、1019、1021、1028、1029、  1032、1037、1040、1048、1056、1058、1061、1070、1076、1089、1090、1091、1092、1093、  1094、1095、1096、1097、1098、1106、1108、1157、1163、1164、1170、11...
HDU题目分类
qq_43605848的博客
04-09 716
基础题：1000、1001、1004、1005、1008、1012、1013、1014、1017、1019、1021、1028、1029、 1032、1037、1040、1048、1056、1058、1061、1070、1076、1089、1090、1091、1092、1093、 1094、1095、1096、1097、1098、1106、1108、1157、1163、1164、1170、1194...
转载：Hdu 题目分类
Hawo11的博客
10-16 1565
原址点击基础题：1000、1001、1004、1005、1008、1012、1013、1014、1017、1019、1021、1028、1029、 1032、1037、1040、1048、1056、1058、1061、1070、1076、1089、1090、1091、1092、1093、 1094、1095、1096、1097、1098、1106、1108、1157、1163、1164、11
hdu题目分析（简介）
逆水行舟
08-22 3027
hdu题目大致分类：（详细分类在后）   模拟题, 枚举 1002 1004 1013 1015 1017 1020 1022 1029 1031 1033 1034 1035 1036 1037 1039 1042 1047 1048 1049 1050 1057 1062 1063 1064 1070 1073 1075 1082 1083 1084 1088 1106 1107 111
hdu HDOJ 题目分类（转）
小人物的草稿本
07-05 3153
动态规划：2037 2054 2084 hdu题目分类（转） http://apps.hi.baidu.com/share/detail/17053154 1001 整数求和 水题 1002 C语言实验题——两个数比较 水题 1003 1、2、3、4、5... 简单题 1004 渊子赛马 排序+贪心的方法归并 1005 Hero In Maze 广
ACM hdu 线段树题目+源代码
06-19
ACM hdu 线段树题目+源代码 线段树是一种非常重要的数据结构，它广泛应用于算法竞赛和实际编程中。今天，我们将通过 ACM hdu 的几个题目来学习和掌握线段树的基本概念和应用。 线段树的基本概念 线段树是一种...
【HDU 3333 Turing Tree】离线处理+线段树+莫队
我是谁 --- 卡比兽
07-17 203
HDU 3333 题目大意：给你一串长度为n(n <= 30000)的序列，编号从1开始，序列中每个元素最大不超过10^9。 接下来Q组询问，每组是一个区间，要你回答这个区间中不相同的数之和为多少。 这道题之前自己做一直不会 学了莫队以后套个线段树过了 就是把询问先离线 按照 r 的大小从小到大排序 然后每到一个下标 就看这个下标的那个数之前有没有被插入过 如果插入过 就更新为新的下标新的值...
hdu5200 Trees（逆向思维+离线处理）
Crazy_Bear
08-03 716
题意描述： 在一条直线上有n棵树，每棵树有一个高度。现在进行查询：给一个高度h，把小于等于h的树砍掉，剩余的树能组成几个块？ 块的定义：一个块要包含尽可能多的位置连续的树，而且被包含的树没有被砍掉 解题思路：离线处理 1、逆向思维：砍树的对立面就是长树                 （1）如果我们把树的高度和查询高度都按从大到小的顺序排序，初始化直线上没有一棵树存在；    
hdu 5869 - 树状数组 + 离线 + 离散(扩展)
过路人丶的博客
05-17 333
解题思路:首先这题a[i]值最大1e6所以可以不用考虑离散化，但是为了方便数据扩大我强行再加了一个log(n)复杂度进行数据离散化。所以现在的复杂度应该是nlog(n)*log(n),不离散的话一个log(n)就可以了。vec[i]数组保存保存区间右界为i的所有gcd情况和该gcd最后出现的位置，那么从i位置一直向左扫gcd肯定是会越来越小的或者不变，变小的话最少变小2倍，所以一个前缀gcd个数不...
hdu 4578 Transformation2013杭州邀请赛C(简单线段树)
ophunter的专栏
08-10 2761
Transformation Time Limit: 15000/8000 MS (Java/Others)    Memory Limit: 65535/65536 K (Java/Others) Total Submission(s): 0    Accepted Submission(s): 0 Problem Description Yuanfang is puzz
poj3076Sudoku(我大DLX威武！16*16数独秒解！！)
ophunter的专栏
06-01 2161
->题目请戳这里 题目大意：16*16数独。 题目分析：建模同这篇9*9数独，就不多废话了，详情请见代码： #include #include #include #include using namespace std; const int N = 16 * 16 * 16 * 16 * 16 * 4 + 5;//16 * 16 * 16行16 * 16 * 4列 int s[N],h[N
hdu4614 Vases and Flowers(简单线段树 + 二分)
ophunter的专栏
08-10 1954
Vases and Flowers Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission(s): 1336    Accepted Submission(s): 532 Problem Description 　　Alice i
poj1785&zoj2243 Binary Search Heap Construction(笛卡尔树)
ophunter的专栏
07-14 1827
Binary Search Heap Construction Time Limit: 5 Seconds      Memory Limit: 32768 KB Read the statement of problem G for the definitions concerning trees. In the following we define the basic termi
poj3074Sudoku(DLX解9*9数独)
ophunter的专栏
06-01 1803
->题目请戳这里 题目大意：填9*9数独，就不多废话了。 题目分析：以前写数独是用搜索做的，略带暴力枚举，代码量比较大，效率也不高，最近学dancing links，用来解决精确覆盖问题，效率蛮高，而且代码非常优雅。关于数独转化成精确覆盖问题，这篇论文讲的很详细，就不在这里班门弄斧了，详情请见代码： #include #include #include #include using nam
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值