【刷题笔记】第五天

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]链表里
            // 在插入之前，先判断链表里是否存在key
            Node 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)
    // 所以数组长度定为31251
    public int[] table = new int[31251];

    public MyHashSet() {

    }
    
    public void add(int key) {
        int index = key >> 5; // 相当于除以32
        int bitIndex = key & 31; // 相当于key % 32
        table[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; // 相当于除以32
        int bitIndex = key & 31; // 相当于key % 32
        return ((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 stub
		Scanner 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

迭代加深搜索

目标字符串的长度是未知的，所以应该从所有序列的最大长度开始搜索

通过剪枝限制递归的深度

剪枝策略：如果已经匹配的字符个数+最长待匹配字符数 > 目标字符串的长度，则直接返回false，表示之前的匹配方案无效。

对于最长待匹配字符数，有两种计算方法：

方法一：统计所有序列中最长的待匹配字符数

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

方法二：统计所有序列的待匹配部分中A出现的最多次数+C出现的最多次数+G出现的最多次数+T出现的最多次数，并返回

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) {
		// 待匹配字符数为0
		return 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;
}