poj1840Eqs【散列表】

Description

Consider equations having the following form: 
a1x1 3+ a2x2 3+ a3x3 3+ a4x4 3+ a5x5 3=0 
The coefficients are given integers from the interval [-50,50]. 
It is consider a solution a system (x1, x2, x3, x4, x5) that verifies the equation, xi∈[-50,50], xi != 0, any i∈{1,2,3,4,5}.

Determine how many solutions satisfy the given equation.

Input

The only line of input contains the 5 coefficients a1, a2, a3, a4, a5, separated by blanks.

Output

The output will contain on the first line the number of the solutions for the given equation.

Sample Input

37 29 41 43 47

Sample Output

654

分析:把前两个hash一下进行存值然后再后面查询有没有出现过即可

代码:

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <cmath>
 5 using namespace std;
 6
 7 const int mod = 100007;
 8
 9 struct Node {
10     int d;
11     Node* next;
12 };
13
14 Node* head[mod + 10];
15 Node nd[mod + 10];
16
17 int main() {
18     int a, b, c, d, e;
19     while(EOF != scanf("%d %d %d %d %d",&a, &b, &c, &d, &e) ) {
20         memset(head, 0, sizeof(head));
21         int n_cnt = 0;
22         for(int i = -50; i <= 50; i++) {
23             for(int j = -50; j <= 50; j++) {
24                 if(i == 0 || j == 0) continue;
25                 int num = a * i * i * i + b *j * j * j;
26                 int xx = num > 0 ? num : -num;
27                 int p = xx % mod;
28                 Node*pt = head[p];
29                 while(pt) {
30                     pt = pt -> next;
31                 }
32                 nd[n_cnt].d = num;
33                 nd[n_cnt].next = head[p];
34                 head[p] = &nd[n_cnt++];
35             }
36         }
37         int ans = 0;
38         for(int i = -50; i <= 50; i++) {
39             for(int j = -50; j <= 50; j++) {
40                 for(int k = -50; k <= 50; k++) {
41                     if(i == 0 || j == 0 || k == 0) continue;
42                     int num = c * i * i * i + d * j * j * j + e * k * k * k;
43                     num = - num;
44                     int xx = num > 0 ? num : - num;
45                     int p = xx % mod;
46                     Node * pt = head[p];
47                     while(pt) {
48                         if(pt -> d == num) ans++;
49                         pt = pt -> next;
50                     }
51                 }
52             }
53         }
54         printf("%d\n", ans);
55     }
56     return 0;
57 }

动态内存申请

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 using namespace std;
 5
 6 const int mod = 10007;
 7
 8 struct Node {
 9     int to;
10     int next;
11 }e[mod + 10];
12
13 int head[mod + 10];
14
15 int tot;
16 void add(int u, int v) {
17     e[tot].to = v;
18     e[tot].next = head[u];
19     head[u] = tot++;
20 }
21
22 int Find(int p, int num) {
23     int cnt = 0;
24     for(int i = head[p]; i; i = e[i].next) {
25         if(e[i].to == num) cnt++;
26     }
27     return cnt;
28 }
29
30 int Fabs(int x) {
31     return x > 0 ? x : - x;
32 }
33
34 int main() {
35     int a, b, c, d, e;
36     while(EOF != scanf("%d %d %d %d %d",&a, &b, &c, &d, &e) ) {
37         memset(head, 0, sizeof(head));
38         tot = 1;
39         for(int i = -50; i <= 50; i++) {
40             for(int j = -50; j <= 50; j++) {
41                 if(i == 0 || j == 0) continue;
42                 int num = a * i * i * i + b * j * j * j;
43                 int p = Fabs(num) % mod;
44                 add(p, num);
45             }
46         }
47         int ans = 0;
48         for(int i = -50; i <= 50; i++) {
49             for(int j = -50; j <= 50; j++) {
50                 for(int k = -50; k <= 50; k++) {
51                     if(i == 0 || j == 0 || k == 0) continue;
52                     int num = c * i * i * i + d * j * j * j + e * k * k * k;
53                     num = - num;
54                     int p = Fabs(num) % mod;
55                     ans += Find(p, num);
56                 }
57             }
58         }
59         printf("%d\n",ans);
60     }
61     return 0;
62 }

数组模拟

				
时间: 2024-10-13 02:22:14

poj1840Eqs【散列表】的相关文章

闭散列表的查找、插入和删除操作的完整C代码

/*闭散列表的建立.查找.插入.删除*/ #include <stdio.h> #define NIL -1 //假设关键字为非负整数 #define DEL -2 typedef int KeyType; KeyType HashTable[13]; //便于验证算法,关键字个数假定为不超过13,哈希表长定为13 //关键字插入函数 void InsertHashTable(KeyType k) { for(int i=0; i<13; i++) if( NIL == HashTabl

哈希表/散列表

哈希表/散列表,是根据关键字(key)直接访问在内存存储位置的数据结构. 构造哈希表的常用方法: 直接地址法---取关键字的某个线性函数为散列地址,Hash(Key) = Key或Hash(key) = A*Key + B, A,B为常数. 除留余数法---取关键值被某个不大于散列表长m的数p除后的所得的余数为散列地址. Hash(key) = key % p. 若采用直接地址法(Hash(Key) = Key)存在一定的缺陷. 当Key值特别大时,而Key之前的数很少,就会造成空间浪费.大多时

Python数据结构——散列表

散列表的实现常常叫做散列(hashing).散列仅支持INSERT,SEARCH和DELETE操作,都是在常数平均时间执行的.需要元素间任何排序信息的操作将不会得到有效的支持. 散列表是普通数组概念的推广.如果空间允许,可以提供一个数组,为每个可能的关键字保留一个位置,就可以运用直接寻址技术. 当实际存储的关键字比可能的关键字总数较小时,采用散列表就比较直接寻址更为有效.在散列表中,不是直接把关键字用作数组下标,而是根据关键字计算出下标,这种 关键字与下标之间的映射就叫做散列函数. 1.散列函数

散列表的实现

一,线性探測法 核心:冲突的时候线性的向下寻找可用空间; 缺点:对同一散列地址的争夺现象会出现堆积; 二,二次探測法 核心:冲突的时候探測以下的+_k^2; 缺点:不易探測到整个散列表的全部空间: 三,链地址法 同一地址放置一条链

散列表

散列表的基本思想通过键来直接计算出数据的存放地址,而避免了数组或者其他数据结构的逐个比较查找. 可以在常数时间内实现查找.插入和删除操作,代价是不支持任何有关排序的操作. 键到地址的映射,称作散列函数.散列函数需要满足两个要求:计算简单:冲突少. 不同的情况,可以有不同的散列函数,在此不对散列函数做过多介绍. 冲突:相同的键,通过散列函数,被映射到了相同的地址.下面主要介绍下解决冲突的一些简单方法. 分离链表法:把散列到同一个地址的数据保存在一个链表中.在查询数据时,先通过散列函数求出链表地址,

散列表(数据结构学习笔记)

散列 散列表的一般实现叫散列.是一种以常数平均时间执行插入.删除.查找的技术.理想的散列表结构是一个包含关键字具有固定大小的数组.典型情况是,一个关键字就是一个带有相关值的字符串.把表大小记MaxSize,通常使表在0-MaxSize之间变化.每个关键字都被映射到0-MaxSize之间的某个单元中.这个映射关系就是散列函数.理想情况函数保证任何关键字都映射到不同单元里,实践是不可能的.因数组有限大小,而关键字可无限多.因此要找德散列函数尽可能的使关键字均匀的分布在单元中.如图 git在0号单元,

十三、散列表(哈希表)

散列表 散列表插入分两步: 1. 根据散列函数找到索引 2. 处理索引冲突情况:拉链法和线性探测法 散列表是时间上和空间上作出权衡的一个例子.散列表采用函数映射找索引,查找很快,但是键的顺序信息不会保存(HashSet HashMap的本质) 散列函数 对于每种类型的键我们都学要一个与之对应的散列函数 正整数散列: 常用取余散列:k%M 浮点数散列: 例如0-1之间可以乘以一个M得到0-M-1之前的索引值,但是高位影响比低位大(0.12的1比2的影响更大,不符合均匀性),所以可以将键表示为二进制

算法导论 第十章 基本数据类型 &amp; 第十一章 散列表(python)

更多的理论细节可以用<数据结构>严蔚敏 看几遍,数据结构很重要是实现算法的很大一部分 下面主要谈谈python什么实现 10.1 栈和队列 栈:后进先出LIFO 队列:先进先出FIFO python 中使用list实现在这些功能 栈:压栈 append() 退栈   pop() 队列:   入队 append() 出队 pop(0) 栈: >>> stack = list() >>> stack.append(3) >>> stack.ap

大话数据结构—散列表查找(哈希表)

一.基本概念 散列技术:在记录的存储位置和它的关键字之间建立一个确定的对应关系f,使得每个关键字key对应一个存储位置f(key). f:散列函数/哈希函数: 采用散列技术将记录存储在一块连续的存储空间中,这块连续存储空间称为散列表或哈希表. 关键字对应的记录存储位置称为散列地址. 散列技术既是一种存储方法,也是一种查找方法. 散列技术适合求解问题是查找与给定值相等的记录.查找速度快. 散列技术不适合范围查找,不适合查找同样关键字的记录,不适合获取记录的排序,最值. 冲突:关键字key1不等于k

算法导论-散列表(Hash Table)

目录 引言 直接寻址 散列寻址 散列函数 除法散列 乘法散列 全域散列 完全散列 碰撞处理方法 链表法 开放寻址法 线性探查 二次探查 双重散列 随机散列 再散列问题 完整源码(C++) 参考资料 内容 1.引言 如果想在一个n个元素的列表中,查询元素x是否存在于列表中,首先想到的就是从头到尾遍历一遍列表,逐个进行比较,这种方法效率是Θ(n):当然,如果列表是已经排好序的话,可以采用二分查找算法进行查找,这时效率提升到Θ(logn);  本文中,我们介绍散列表(HashTable),能使查找效率