hdu6085 Rikka with Candies

最新推荐文章于 2019-08-20 14:47:09 发布
最新推荐文章于 2019-08-20 14:47:09 发布
阅读量1k 收藏
点赞数 1
文章标签： 压位
[cpp] view plain copy
print ?
  1. /** 
  2. HDU 6085 Rikka with Candies 
  3. 题意：A数组n个数，B数组m个数，q个查询， 每次给出一个k，询问有多少对(i,j)， 使得Ai % Bj = k， 输出对数对模2的值 
  4.  
  5. 思路：首先，用一个vis数组01方式记录A数组中的数是否出现过，因为有Ai % Bj = k，所以也就是(Ai - k) % Bj = 0，不妨设Ai - k = x，那么Bj则是x的因子，因为 
  6. 是Ai % Bj = k，所以k一定比Bj小，即k的取值范围是[0, Bj)那么可以枚举每个x， 再枚举每个x的因子c，如果c不在B数组出现， 就不管它；否则的话，就在[0, Bj) 
  7. 中的每一个y的值， 对应的加上vis数组中x + y的值，举个例子： 
  8. vis数组中对于6 7 8 9 10 11的出现情况是0 1 1 0 1 0 
  9. 对于x枚举到6，它的因子枚举到3(假设3在B数组存在)的时候，如果有(Ai - k) % 3 = 0，那么就是说,如果k可以取值，k在[0, 3)也就是[0, 2]的范围内，也就转换为 
  10. Ai = x + k， 也就是6 + [0, 2]，那么现在只需要看对应取值为k的时候，x + k(Ai)是否存在，如果存在那么k的值即可加上1， 因为此时(Ai, 3)形成了一对模为k的数 
  11. 设res数组是记录余数为k的对数， x=6,c=3的情况如下所示 
  12. vis 6  7  8  9 10 11 
  13.     0  1  1  0  1  0 
  14.  
  15. x+k 6 7 8 
  16.  
  17.   res[0, 1, 2] + vis[x + 0, x + 1, x + 2] 
  18. = res[0, 1, 2] + vis[6, 7, 8] 
  19. = res[0, 1, 2] + [0, 1, 1] 
  20. 就是说res[0]+0, res[1]+1, res[2]+1, 代表有(6+1)%3=0,(6+2)%3=0， 
  21. 即(7, 3)形成了一对余数为1的数，(8, 3)形成了一对余数为2的数 
  22.  
  23. 还有因为直接相加复杂度是O(n^2),题目说只需要模2， 那么可以用异或来写，用异或的话也不可能一个一个来，所以就用将连续若干个01值压缩成一个整数来异或， 
  24. 这样就是O(n^2 / 32), 还有一点就是对于x=0，因为所有正整数都是0的因子，对0分开写，原式就是(0 + k) % Bj = k => k % Bj = k， 就是找在A数组中k存在的前提 
  25. 下，在B数组中找出比k大的数的数量加进res[k]即可 
  26. **/  
  27.   
  28. #include<bits/stdc++.h>  
  29. typedef long long ll;  
  30. const int MAXN = 5e4 + 70;  
  31. using namespace std;  
  32. int a[MAXN], b[MAXN];  
  33. int res[MAXN], vis[MAXN];  
  34. vector<int> G[MAXN];  
  35. ll dig[MAXN][35];  
  36. set<int> st;  
  37. ll ans[MAXN];  
  38.   
  39. void init() {  
  40.     for(int i = 1; i < MAXN - 3; i++) {  
  41.         for(int j = 1; j * j <= i; j++) {  
  42.             if(i % j) continue;  
  43.             G[i].push_back(j);  
  44.             if(i / j != j) G[i].push_back(i / j);  
  45.         }  
  46.         sort(G[i].begin(), G[i].end());  
  47.     }  
  48. }  
  49.   
  50. int main() {  
  51.     init();  
  52.     int n, m, q, k, T;  
  53.     scanf("%d", &T);  
  54.     while(T--) {  
  55.         st.clear();  
  56.         memset(vis, 0, sizeof vis);  
  57.         memset(res, 0, sizeof res);  
  58.         memset(ans, 0, sizeof ans);  
  59.         scanf("%d%d%d", &n, &m, &q);  
  60.         int max_data = -1;  
  61.         for(int i = 0; i < n; i++) {  
  62.             scanf("%d", &a[i]);  
  63.             vis[a[i]] = 1;  
  64.             max_data = max(max_data, a[i]);  
  65.         }  
  66.         for(int i = 0; i < m; i++) {  
  67.             scanf("%d", &b[i]);  
  68.             st.insert(b[i]);  
  69.         }  
  70.         sort(b, b + m);  
  71.         for(int i = 1; i <= 5e4; i++) {  
  72.             ll su = 0;  
  73.             for(int j = 0; j < 32; j++) {  
  74.                 su = su * 2 + vis[i + j];  
  75.                 dig[i][j + 1] = su;  
  76.                 dig[i][j + 1] <<= (31 - j);  
  77.             }  
  78.         }  
  79.   
  80.         for(int i = 1; i <= max_data; i++) {  
  81.             for(int j = 0; j < G[i].size(); j++) {  
  82.                 int x = G[i][j];  
  83.                 if(!st.count(x)) continue;  
  84.                 int L = 0, R = x - 1;  
  85.                 while(L <= R) {  
  86.                     int d = L / 32;  
  87.                     if(i + L > 5e4) break;  
  88.                     if(R - L >= 31) {  
  89.                         ans[d] ^= dig[i + L][32];  
  90.                         L += 32;  
  91.                     } else {  
  92.                         ans[d] ^= dig[i + L][R - L + 1];  
  93.                         L = R + 1;  
  94.                     }  
  95.                 }  
  96.             }  
  97.         }  
  98.   
  99.         int num = 0;  
  100.         for(int i = 0; i * 32 <= 5e4; i++) {  
  101.             int j = (i + 1) * 32 - 1;  
  102.             int t = 32;  
  103.             while(t--) { res[j] = ans[i] & 1; j--; ans[i] >>= 1; }  
  104.         }  
  105.         for(int i = 0; i < n; i++) {  
  106.             int x = a[i];  
  107.             res[x] += m - (upper_bound(b, b + m, x) - b);  
  108.         }  
  109.         while(q--) {  
  110.             scanf("%d", &k);  
  111.             printf("%d\n", res[k] & 1);  
  112.         }  
  113.     }  
  114.     return 0;  
  115. }  
/**
HDU 6085 Rikka with Candies
题意：A数组n个数，B数组m个数，q个查询， 每次给出一个k，询问有多少对(i,j)， 使得Ai % Bj = k， 输出对数对模2的值

思路：首先，用一个vis数组01方式记录A数组中的数是否出现过，因为有Ai % Bj = k，所以也就是(Ai - k) % Bj = 0，不妨设Ai - k = x，那么Bj则是x的因子，因为
是Ai % Bj = k，所以k一定比Bj小，即k的取值范围是[0, Bj)那么可以枚举每个x， 再枚举每个x的因子c，如果c不在B数组出现， 就不管它；否则的话，就在[0, Bj)
中的每一个y的值， 对应的加上vis数组中x + y的值，举个例子：
vis数组中对于6 7 8 9 10 11的出现情况是0 1 1 0 1 0
对于x枚举到6，它的因子枚举到3(假设3在B数组存在)的时候，如果有(Ai - k) % 3 = 0，那么就是说,如果k可以取值，k在[0, 3)也就是[0, 2]的范围内，也就转换为
Ai = x + k， 也就是6 + [0, 2]，那么现在只需要看对应取值为k的时候，x + k(Ai)是否存在，如果存在那么k的值即可加上1， 因为此时(Ai, 3)形成了一对模为k的数
设res数组是记录余数为k的对数， x=6,c=3的情况如下所示
vis 6  7  8  9 10 11
    0  1  1  0  1  0

x+k 6 7 8

  res[0, 1, 2] + vis[x + 0, x + 1, x + 2]
= res[0, 1, 2] + vis[6, 7, 8]
= res[0, 1, 2] + [0, 1, 1]
就是说res[0]+0, res[1]+1, res[2]+1, 代表有(6+1)%3=0,(6+2)%3=0，
即(7, 3)形成了一对余数为1的数，(8, 3)形成了一对余数为2的数

还有因为直接相加复杂度是O(n^2),题目说只需要模2， 那么可以用异或来写，用异或的话也不可能一个一个来，所以就用将连续若干个01值压缩成一个整数来异或，
这样就是O(n^2 / 32), 还有一点就是对于x=0，因为所有正整数都是0的因子，对0分开写，原式就是(0 + k) % Bj = k => k % Bj = k， 就是找在A数组中k存在的前提
下，在B数组中找出比k大的数的数量加进res[k]即可
**/

#include<bits/stdc++.h>
typedef long long ll;
const int MAXN = 5e4 + 70;
using namespace std;
int a[MAXN], b[MAXN];
int res[MAXN], vis[MAXN];
vector<int> G[MAXN];
ll dig[MAXN][35];
set<int> st;
ll ans[MAXN];

void init() {
    for(int i = 1; i < MAXN - 3; i++) {
        for(int j = 1; j * j <= i; j++) {
            if(i % j) continue;
            G[i].push_back(j);
            if(i / j != j) G[i].push_back(i / j);
        }
        sort(G[i].begin(), G[i].end());
    }
}

int main() {
    init();
    int n, m, q, k, T;
    scanf("%d", &T);
    while(T--) {
        st.clear();
        memset(vis, 0, sizeof vis);
        memset(res, 0, sizeof res);
        memset(ans, 0, sizeof ans);
        scanf("%d%d%d", &n, &m, &q);
        int max_data = -1;
        for(int i = 0; i < n; i++) {
            scanf("%d", &a[i]);
            vis[a[i]] = 1;
            max_data = max(max_data, a[i]);
        }
        for(int i = 0; i < m; i++) {
            scanf("%d", &b[i]);
            st.insert(b[i]);
        }
        sort(b, b + m);
        for(int i = 1; i <= 5e4; i++) {
            ll su = 0;
            for(int j = 0; j < 32; j++) {
                su = su * 2 + vis[i + j];
                dig[i][j + 1] = su;
                dig[i][j + 1] <<= (31 - j);
            }
        }

        for(int i = 1; i <= max_data; i++) {
            for(int j = 0; j < G[i].size(); j++) {
                int x = G[i][j];
                if(!st.count(x)) continue;
                int L = 0, R = x - 1;
                while(L <= R) {
                    int d = L / 32;
                    if(i + L > 5e4) break;
                    if(R - L >= 31) {
                        ans[d] ^= dig[i + L][32];
                        L += 32;
                    } else {
                        ans[d] ^= dig[i + L][R - L + 1];
                        L = R + 1;
                    }
                }
            }
        }

        int num = 0;
        for(int i = 0; i * 32 <= 5e4; i++) {
            int j = (i + 1) * 32 - 1;
            int t = 32;
            while(t--) { res[j] = ans[i] & 1; j--; ans[i] >>= 1; }
        }
        for(int i = 0; i < n; i++) {
            int x = a[i];
            res[x] += m - (upper_bound(b, b + m, x) - b);
        }
        while(q--) {
            scanf("%d", &k);
            printf("%d\n", res[k] & 1);
        }
    }
    return 0;
}

Dijkstra__
关注
HDU6085 Rikka with Candies
dDarkdawn的博客
08-09 1019
题目链接题意​ 存在两个长度分别为 n,mn,m 的数组 A,BA,B 。有 qq 个询问，每个询问给出一个数字 kk ，可以得到使得 AimodBj=kA_i \mod B_j = k 的种数。求该种数的奇偶性。分析​ 由于只需要求出种数的奇偶性，容易发现奇偶性的变化和2进制中亦或的结果相同。于是想到利用位操作来进行优化。对于BiB_i ，可以不断的枚举区间 [kBi,(k+1)Bi−1]
hdu 6085 Rikka with Candies bitset
zstu_zy的博客
08-09 1062
Rikka with CandiesTime Limit: 7000/3500 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 553 Accepted Submission(s): 232Problem Description As we know, Rikka is p
hdu 6085 Rikka with Candies
但求心安的博客
08-17 355
bitset怎么鬼？，还有这种操作？ 百度一波bitset，这种操作令人窒息。 首先思路：如果a%b==k b肯定大于k，不用想的事情，所以从最大的b开始枚举。 a%b=k 就是a-b*j=k,就是a-k=b*j 所以： #include using namespace std; const int N =50000+5; bitseta,b,ans,bx; void solve(in
HDU 6085 Rikka with Candies
hnust_Derker的博客
08-09 1940
/** HDU 6085 Rikka with Candies 题意：A数组n个数，B数组m个数，q个查询， 每次给出一个k，询问有多少对(i,j)， 使得Ai % Bj = k， 输出对数对模2的值 思路：首先，用一个vis数组01方式记录A数组中的数是否出现过，因为有Ai % Bj = k，所以也就是(Ai - k) % Bj = 0，不妨设Ai - k = x，那么Bj则是x的因子，因为
HDU6085-Rikka with Candies
wang_128的博客
08-12 465
Rikka with Candies                                                                    Time Limit: 7000/3500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
2017多校联合第五场1001/hdu6085Rikka with Candies（bitset）
The_star_is_at的博客
08-11 827
Rikka with Candies Time Limit: 7000/3500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 1389    Accepted Submission(s): 606 Problem Description As we kn
HDU 6085 Rikka with Candies bitset
06-29 72
HDU 6085 考虑枚举 B[ i ]， 分成50000 / B[ i ] 段每段用bitset处理， 手写bitset的话复杂度n ^ 2 / 32。 训练的时候我没有手写bitset， 靠卡常加开o3优化卡过去了。 其实有一种方法能用手写bitset做到n ^ 2 / 32 + n * log(n)， 感觉很巧妙呀。 博客在这里https://blog.csdn.ne...
HDU 6085 Rikka with Candies （bitset）
小坏蛋_千千
10-03 308
Description As we know, Rikka is poor at math. Yuta is worrying about this situation, so he gives Rikka some math tasks to practice. There is one of them: There are n children and m kinds of can
hdu 6085 Rikka with Candies（bitset容器）
咸鱼有梦想
08-11 261
Rikka with Candies Time Limit: 7000/3500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 1422    Accepted Submission(s): 617 Problem Description As we know,
HDU Rikka with Phi（线段树）
苟为蒟蒻又何妨
07-03 380
Rikka with Phi Time Limit: 16000/8000 MS (Java/Others) Memory Limit: 131072/131072 K (Java/Others) Problem Description Rikka and Yuta are interested in Phi function (which is known as Euler’s to...
2017多校五 1011题 hdu 6095 Rikka with Competition
kkkkahlua的博客
08-09 425
题目链接 题意： n 个人之间进行 n - 1 场比赛（淘汰赛），第 i 个人的能力值为 ai. 在 i 与 j PK 时，当且仅当 |ai - aj] > K 时，这一局才有确定的胜者，即能力值高的人；否则两人均可能获胜。给出 n 个人的能力值，问最终的胜者可能有几种情况。 思路： 一个人如果 A 能力值低还要能成为最后的赢家，那他肯定至少要侥幸打败最近的比他能力值高的人
HDU 6086 Rikka with String(2017 Multi-University Training Contest 3)
CantSayAWord的博客
08-16 433
题目链接：Rikka with String 题意：给定nn个0101字符串和一个长度LL，问所有长度为2∗L2*L的反对称字符串（s[i]≠s[|s|−i+1],i∈[1,|s|]s[i]≠s[|s|−i+1],i∈[1,|s|]）中出现所有给定字符串的种类数。 题解：我们先考虑一个简化版的问题：所有长度为LL的字符串中出现所有给定字符串的种类数。这就是一个基本的AC自动机上dpdp的问题，记
2019多校第九场 HDU6681 Rikka with Cake（欧拉图论定理，线段树）
Plus Ultra！
08-20 177
链接：HDU6681 Rikka with Cake 题意： 给出一个笛卡尔坐标系中左下角坐标为(0,0)(0,0)(0,0)，右上角坐标为(n,m)(n,m)(n,m)的矩形，有K&ThickSpace;(≤105)K\;(\le 10^5)K(≤105)条射线，起点在矩形内部，其坐标为(xi,yi)(x_i,y_i)(xi​,yi​)，方向为上/下/左/右（U/D/L/R)U/D/L/...
HDU 6416 2018HDU多校赛 第九场 Rikka with Seam（dp + 前缀和优化）
alpc_qleonardo
08-21 656
大致题意：给你一个n*m的01矩阵，现在要让你每一行和每一列都去掉一个数字，而且要求相邻两行之间去掉数字的位置的绝对值要小于等于k。现在问你删除之后的矩形最多有几种。首先，我们一行一行考虑，对于同一行，显然是看有多少个块，有多少个块就有多少个方案。然后对于整个矩阵来说，任意位置(i,j)可以从上一行的(j-k,j+k)之间转移过来。dp[i][j]表示不考虑重复的情况下，处理到第i行，且第i行删掉第j个位置的方案数。那么，显然根据之前说的转移区间，有转移方程：
考虑励磁控制系统的水热两区互联电力系统网络自动生成控制simulink.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
Python 实现BO-CNN-BiLSTM贝叶斯优化卷积双向长短期记忆网络数据多变量时间序列预测（包含详细的完整的程序和数据）
10-09
内容概要：本文详细介绍了如何使用 Python 和深度学习方法（包括卷积神经网络 CNN 与双向长短期记忆网络 BiLSTM 结合的 BO-CNN-BiLSTM）进行多变量时间序列的数据预测。内容涵盖了从数据准备到超参数优化的全过程，并提供了完整的代码实现和实例展示。 适用人群：机器学习初学者，尤其适合对时间序列预测感兴趣的深度学习爱好者、研究者、工程技术人员。 使用场景及目标：适用于需要对时间序列数据如股票价格、环境数据、医疗健康监控等领域做精准预测的情况。本教程可以帮助理解深度学习在网络模型优化方面的运用。 其它：文中还讨论了项目的注意事项，并指出了可能的方向性改进路径，比如增加模型解释能力、实际应用等
用于kpca降维，对于故障特征诊断具有重要的作用不能运行.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
Python 实现 INFO-ELM（向量加权算法优化极限学习机）进行多输入单输出回归预测（包含详细的完整的程序和数据）
最新发布
10-09
内容概要：本文详细介绍了如何利用PYTHON实现INFO-ELM（一种加权优化极限学习机）来进行多输入单输出（MISO）回归预测的方法。其中包括数据生成、算法建模、权重迭代更新以及最终的效果评估等一系列过程，并附有可视化的结果比较。 适用人群：适合熟悉或正在学习机器学习基本理论，特别是有兴趣深入理解和应用ELM和加权回归算法的研究人员和技术人员。 使用场景及目标：适用于解决多个输入变量对应一个连续数值输出的实际预测问题，通过优化模型提升预测准确性和稳定性。 其他说明：文中还提供了进一步研究和改进的方向，如扩展隐含节点数量、改善权重调节方法及采用平行计算等方式提高预测质量。
ACM HDU题目分类概要
"该资源是关于ACM竞赛中HDU（杭州电子科技大学在线评测系统）题目的分类，包含了从1001到1087的题目简介，涵盖了各种算法和编程技巧，如搜索、动态规划、贪心、数学、字符串处理等。" 在ACM HDU题目分类中，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值