705. 设计哈希集合

实现一：纯数组实现

由于key最大为$10^6$，所以开辟一个$10^6+1$长度的布尔数组，来判断key是否存在。

class MyHashSet {private static int MAX = (int)1e6 + 1;public boolean[] flag;public MyHashSet() {flag = new boolean[MAX];}public void add(int key) {flag[key] = true;}public void remove(int key) {flag[key] = false;}public boolean contains(int key) {return flag[key];}
}

实现二：数组+链表

java中的HshSet的实现原理：

使用HashMap当作数组，其中元素存放在key中。

当添加元素key时，首先计算key在数组中的位置，计算过程如下：

int hash = (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
return hash & (数组长度 - 1)

如果key是空，直接返回0
否则，key的哈希值与右移后的哈希值做异或，结果就是key的新哈希值
然后将新哈希值与长度-1做与，结果就是key在数组中的位置。

添加元素key的流程：
首先计算出key对应的索引index；
如果index位置没有元素，直接放入；否则判断链表里有没有重复元素，若有，则直接返回；
否则将key插入到链表里。

我们仿照这个来实现

class MyHashSet {static class Node {int val;Node next;public Node(int val) {this.val = val;}}// 为了便于计算索引的位置，将数组长度定为2的整数次方 (int)Math.pow(2, 14);// 这个数组的长度可以很小private static final int N = (int)Math.pow(2, 14);Node[] table = new Node[N];public MyHashSet() {//table = new Node[N];}// 获取key在哈希表中的索引private int getIndex(Integer key) {// 为了让 key 对应的 hash 高位也参与运算，这里对 hashCode 进行无符号右移异或// 如果hash小于等于2^16 - 1(65535)，则无符号右移后变为0// 通过将高16位与低16位异或，从而使得 hashCode 的高位随机性和低位随机性都能体现在低 16 位中int hashCode = Integer.hashCode(key);hashCode ^= (hashCode >>> 16);return (N - 1) & hashCode;}public void add(int key) {int index = getIndex(key);if (table[index] == null) {// index位置没元素，直接放table[index] = new Node(key);} else {// index位置有元素了，把key插入到table[index]链表里// 在插入之前，先判断链表里是否存在keyNode pre = null;Node cur = table[index];while (cur != null) {if (cur.val == key) {// key重复了，添加失败return;}pre = cur;cur = cur.next;}// 此时pre是链表的尾节点// 两种插入方式（头插法，尾插法），这里使用尾插法Node node = new Node(key);pre.next = node;}}public void remove(int key) {int index = getIndex(key);Node cur = table[index];if (cur != null) {Node pre = null;while (cur != null) {if (cur.val == key) {if (pre == null) {// 删除链表的头节点table[index] = cur.next;} else {// 删除链表的中间节点pre.next = cur.next;}return;}pre = cur;cur = cur.next;   }}}public boolean contains(int key) {int index = getIndex(key);Node cur = table[index];while (cur != null) {if (cur.val == key) {return true;}cur = cur.next;}return false;}
}

实现三：位运算

int类型有32位，可以表示32个数，那么31250个int，可以表示1000000个数(0~999999)，所以数组长度定为31251

每一个int代表一个块，一共312501个块，每一块里能代表32个数

那如何找到key对应的块呢？
通过key / 32操作

如何找到key在块中的索引呢？
通过key % 32，更高效的做法是key & 31(31的二进制是5个1)

初始时，数组元素置为0，表示一个元素也没有

添加元素：将对应块的位置为1

移除元素：将对应块的位置为0

class MyHashSet {// int类型有32位，可以表示32个数，那么31250个int，可以表示1000000个数(0~999999)// 所以数组长度定为31251public int[] table = new int[31251];public MyHashSet() {}public void add(int key) {int index = key >> 5; // 相当于除以32int bitIndex = key & 31; // 相当于key % 32table[index] |= (1 << bitIndex); // 将table[index]的bitIndex位置1}public void remove(int key) {int index = key >> 5; // 相当于除以32 (块索引)int bitIndex = key & 31; // 相当于key % 32 (位索引)table[index] &= (~(1 << bitIndex)); // 将table[index]的bitIndex位置0}public boolean contains(int key) {int index = key >> 5; // 相当于除以32int bitIndex = key & 31; // 相当于key % 32return ((table[index] >> bitIndex) & 1) == 1;}
}

A + B Problem II

import java.util.Scanner;public class Main{public static String add(String a, String b) {String res = "";int i = a.length() - 1;int j = b.length() - 1;int c = 0; // 进位while (i >= 0 || j >= 0 || c > 0) {// 从低位到高位，一位一位的算char aChar = i >=0 ? a.charAt(i) : '0';char bChar = j >= 0 ? b.charAt(j) : '0';int ans = 0;ans += c;ans += aChar - '0' + bChar - '0';c = ans / 10;res = String.valueOf(ans % 10) + res;i--;j--;}	return res;}public static void main(String[] args) {// TODO Auto-generated method stubScanner sc = new Scanner(System.in);int t = sc.nextInt();for (int i = 0; i < t; ++i) {String a = sc.next();String b = sc.next();String ans = add(a, b);System.out.println("Case " + String.valueOf(i + 1) + ":");System.out.println(a + " + " + b + " = " + ans);System.out.println();}}
}

DNA sequence

int ans = 0;
for(int i = 1; i <= n; ++i) {ans = max(len[i] - pos[i] + 1, ans); //最大待匹配长度 
return ans;

int ans = 0;
// 计算A，C，G，T最多出现次数的累加和
for (int i = 1; i <= 4; ++i) {int maxCnt = 0;// 计算dic[i]最多出现次数for (int j = 1; j <= n; ++j) {// 计算s[j]中 dic[i] 出现的次数int t = 0;for (int k = pos[j]; k <= len[j]; ++k) {t += s[j][k] == dic[i] ? 1 : 0;}maxCnt = max(maxCnt, t);}ans += maxCnt;
}return ans;

#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;
const int MAX_N = 10, MAX_L = 10;char s[MAX_N][MAX_L]; // s[i]:表示第i个序列
int pos[MAX_N]; // pos[i]: 表示第i个序列的第一个待匹配位置
int len[MAX_N]; // len[i]：表示第i个序列的长度
int n, t, res;char dic[5] = { 0, 'A', 'C', 'G', 'T' };int wrong() {int ans = 0;// 计算A，C，G，T最多出现次数的累加和for (int i = 1; i <= 4; ++i) {int maxCnt = 0;// 计算dic[i]最多出现次数for (int j = 1; j <= n; ++j) {// 计算s[j]中 dic[i] 出现的次数int t = 0;for (int k = pos[j]; k <= len[j]; ++k) {t += s[j][k] == dic[i] ? 1 : 0;}maxCnt = max(maxCnt, t);}ans += maxCnt;}return ans;
}// dep表示已经匹配的字符数
bool dfs(int dep) {int temp = wrong();if (temp == 0) {// 待匹配字符数为0return true;}if (dep + temp > res) {// dep + temp 大于序列长度，说明之前的匹配方案无效return false;}vector<int> v;for (int i = 1; i <= 4; ++i) {for (int j = 1; j <= n; ++j) {if (s[j][pos[j]] == dic[i]) {// s[j]序列成功匹配到一个字符pos[j]++;v.push_back(j); // 记录一下，再结束递归时，再恢复现场}}if (v.size() > 0) {// 有序列成功匹配到，才进行递归// 继续匹配if (dfs(dep + 1)) {return true;}else {// 恢复现场while (v.size() > 0) {int tail = v[v.size() - 1];v.pop_back();pos[tail]--;}}}}return false;
}int main() {scanf("%d", &t);while (t--) {scanf("%d", &n);res = 0;for (int i = 1; i <= n; ++i) {memset(s[i], '\0', sizeof(s[i]));scanf("%s", s[i] + 1);pos[i] = 1;len[i] = strlen(s[i] + 1);//printf("s[i]=%s, len[i]=%d\n", s[i], len[i]);res = max(res, len[i]);}while (!dfs(0)) {res++;}printf("%d\n", res);}return 0;
}