标签：输出 数字游戏 char arraylist paper col har 解法 哈希表
这些问题归为哈希表，倒不一定都是要建哈希表来做，有的题目可以用定长的数组起到哈希表的作用。
而且很多题有其他更好一些的方法。
给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]暴力方法时间复杂度要O（ n^2 ），使用哈希表可以降低到O（n）；而且只需一趟扫描存值就可以。
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums[i];
if (map.containsKey(complement)) { //存值之前先在哈希表中查此元素的“配对”元素是否在其中
return new int[] { map.get(complement), i };
}
map.put(nums[i], i);//因为在后续查找中要查的是数组中存的值，所以key存num[i]
}
throw new IllegalArgumentException("No two sum solution");//抛异常
}给定一个整数数组，判断是否存在重复元素。
如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。
最简单的题目了，很多种方法：
1.暴力法 两个for循环 O(n^2) O(1)
2.排序法 先排序 看临近的是否相等 O（NlogN）O(1)
3.哈希表法 一个个往哈希表里存 O(n) O(n)
public boolean containsDuplicate(int[] nums) {
Set<Integer> set = new HashSet<>(nums.length);
for (int x: nums) {
if (set.contains(x)) return true;
set.add(x);
}
return false;
}给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的绝对值最大为 k。
输入: nums = [1,2,3,1], k = 3
输出: true输入: nums = [1,2,3,1,2,3], k = 2
输出: false这题最开始想法是用hashmap，类似I只是加个下标多个判断，但是不够巧妙。高票答案是Buckets方法，哈希表中维持一个容量为k+1个元素的“滑动窗”，相当于在限定窗长度的条件之上找重复，只用hashset就够了。
public boolean containsNearbyDuplicate(int[] nums, int k) {
Set<Integer> set = new HashSet<Integer>();
for(int i = 0; i < nums.length; i++){
if(i > k) set.remove(nums[i-k-1]); //把最前面一个元素删掉
if(!set.add(nums[i])) return true; //add的同时就判断重复了，重复就return
}
return false;
}判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
数独部分空格内已填入了数字，空白格用 ‘.‘ 表示。
输入:
[
["8","3",".",".","7",".",".",".","."],
["6",".",".","1","9","5",".",".","."],
[".","9","8",".",".",".",".","6","."],
["8",".",".",".","6",".",".",".","3"],
["4",".",".","8",".","3",".",".","1"],
["7",".",".",".","2",".",".",".","6"],
[".","6",".",".",".",".","2","8","."],
[".",".",".","4","1","9",".",".","5"],
[".",".",".",".","8",".",".","7","9"]
]
输出: false
解释: 除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。
但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。说明:
一个有效的数独（部分已被填充）不一定是可解的。
只需要根据以上规则，验证已经填入的数字是否有效即可。
给定数独序列只包含数字 1-9 和字符 ‘.‘ 。
给定数独永远是 9x9 形式的。
这题是基于一个矩阵的问题，简单的思路就是将每行，每列，每块分别建一个hashset来判断重复元素（一共建27个）。关键在于怎样巧妙地实现在一个双重for循环当中，怎么样根据二维数组的的两个坐标，将值存到对应的27个哈希表中。
二维数组中的每个值都要遍历到，而且每个值都要存到对应的行列块哈希表中。
下面的代码使用%和／两个运算符来帮助解决矩阵遍历问题；
对于块遍历，它使用如下方式：
0,0，0,1，0,2，<--- 3个水平step，然后是1个垂直step到下一个级别。
1,0，1,1，1,2，<--- 3个水平step，然后是1个垂直step到下一个级别。
2,0，2,1，2,2，<--- 3个水平step。
依次类推....
但是，j的迭代来自于0-9
但我们需要在3个水平step后停止，并垂直向下1个step
使用%来进行水平step，因为j%3 对于每一个j增加1，结果也增加1：0%3 = 0 , 1%3 = 1, 2%3 = 2
增加3次以后重置。所以这包括每个块的水平遍历三次
使用／来进行垂直step 因为／ ，每三个j增加1：0/3 = 0; 1/3 = 0; 2/3 =0; 3/3 = 1
所以到目前为止，对于一个给定的块，可以用j来遍历整个的块。
但是因为j只是0-9，所以只会停留在第一个块，如果要增加块，就要用到i了。
水平step到下一个块，用%，注意这里要乘3了，即ColIndex = 3 * i%3，使得下一个块在3列之后，即0,0第一个块的开始，第二个块是0,3（不是0,1）。同样，要垂直移动到下一个块，要使用/并乘以3。
public boolean isValidSudoku(char[][] board) {
for(int i = 0; i<9; i++){
HashSet<Character> rows = new HashSet<Character>();
HashSet<Character> columns = new HashSet<Character>();
HashSet<Character> cube = new HashSet<Character>();
for (int j = 0; j < 9;j++){
if(board[i][j]!=‘.‘ && !rows.add(board[i][j])) //存行i的set
return false;
if(board[j][i]!=‘.‘ && !columns.add(board[j][i]))//存列i的set
return false;
int RowIndex = 3*(i/3);
int ColIndex = 3*(i%3);
if(board[RowIndex + j/3][ColIndex + j%3]!=‘.‘ && !cube.add(board[RowIndex + j/3][ColIndex + j%3])) //存块i的set
return false;
}
}
return true;
}给定一个字符串，找出不含有重复字符的最长子串的长度。
示例：
给定 "abcabcbb" ，没有重复字符的最长子串是 "abc" ，那么长度就是3。
给定 "bbbbb" ，最长的子串就是 "b" ，长度是1。
给定 "pwwkew" ，最长子串是 "wke" ，长度是3。请注意答案必须是一个子串，"pwke" 是序列而不是子串。
无重复问题使用哈希表是一个方法，要注意选用hashset还是hashmap；这道题技巧在于使用hashmap同时存值和下标;在检测重复的能够定位到重复的值的那个下标。使用双指针标记子串起止，试图扩展子串。
public int lengthOfLongestSubstring(String s) {
int n = s.length(), ans = 0;
Map<Character, Integer> map = new HashMap<>(); // current index of character
// try to extend the range [i, j]
for (int j = 0, i = 0; j < n; j++) {
if (map.containsKey(s.charAt(j))) {
i = Math.max(map.get(s.charAt(j))+1, i);//i不必每次只增加1，而是一步到位，加到与当前元素重复的旧索引处+1。
//i不能回退，更新时取最大，例如：“caac“
}
map.put(s.charAt(j), j);
ans = Math.max(ans, j - i+1 ); //更新最大长度ans
}
return ans;
}给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的一个字母异位词。
说明:
你可以假设字符串只包含小写字母。
进阶:
如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
输入: s = "anagram", t = "nagaram"
输出: true输入: s = "rat", t = "car"
输出: false如果只考虑只包含小写字母，就是建一个长度为26的数组，数组中的每个位置相当于对应字母的计数器，最后检查数组并返回。
也还有其他方法：
1.排序法 String转为CharArray再排序
2.哈希表法 用hashmap存，value存出现的次数
3.素数法（不好，溢出） 每个字母用不同的素数表示，乘起来，结果一样说明是字母异位
public boolean isAnagram(String s, String t) {
if (s.length()!=t.length()) return false;
char[] a=new char[26];
for (int i=0;i<s.length();i++){
a[s.charAt(i)-‘a‘]++;
a[t.charAt(i)-‘a‘]--;
}
for (int j=0;j<a.length;j++){
if (a[j]!=0) return false;
}
return true;
}给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。
输入: ["eat", "tea", "tan", "ate", "nat", "bat"],
输出:
[
["ate","eat","tea"],
["nat","tan"],
["bat"]
]说明：
所有输入均为小写字母。
不考虑答案输出的顺序。
这题的常规想法肯定就是使用一个长度为26的数组来存一个字符串中相应位置上的字母是有还是无，如果两个字符串是异位词，那么纪录后的两个数组一定是一样的。但是这么做还是不好，复杂度最高O（N^2）。
这题的技巧在于sort。一个字符串转为字符数组后可以进行sort操作。这样，如果两个字符串是异位词，sort后是一样的。使用hashmap，key是sort后的字符串，value是List
public List<List<String>> groupAnagrams(String[] strs) {
if (strs == null || strs.length == 0) return new ArrayList<List<String>>();
Map<String, List<String>> map = new HashMap<String, List<String>>();
for (String s : strs) {
char[] ca = s.toCharArray();
Arrays.sort(ca);
String keyStr = String.valueOf(ca);
if (!map.containsKey(keyStr)) map.put(keyStr, new ArrayList<String>());
map.get(keyStr).add(s);
}
return new ArrayList<List<String>>(map.values());//这一步ArrayList的构造方法，注意map.values()返回的是map中所有值的一个视图。
}所有 DNA 由一系列缩写为 A，C，G 和 T 的核苷酸组成，例如：“ACGAATTCCG”。在研究 DNA 时，识别 DNA 中的重复序列有时会对研究非常有帮助。
编写一个函数来查找 DNA 分子中所有出现超多一次的10个字母长的序列（子串）。
输入: s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
输出: ["AAAAACCCCC", "CCCCCAAAAA"]这题需要遍历所有长度为10的子串是无法避免的（一共有n-9个长度为10的子串）。在遍历的同时要判断重复出现要用到哈希表；但是是要找出重复出现的子串，这时就还要用另一个哈希表（由于最后的结果中肯定不能有重复，所以还是选用哈希表）存放重复出现的子串，而第一个哈希表只起到判断重复的作用。
这题还有一种位运算的解法可以节省空间（哈希表中不存String存Integer）
public List<String> findRepeatedDnaSequences(String s) {
Set seen = new HashSet(), repeated = new HashSet();
for (int i = 0; i + 9 < s.length(); i++) {
String ten = s.substring(i, i + 10);
if (!seen.add(ten))
repeated.add(ten); //遇到重复子串添加到结果，repeated是哈希表是为了防止结果重复
}
return new ArrayList(repeated); //用hashset初始化arraylist
}给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。
所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。
输入: s = "egg", t = "add"
输出: true输入: s = "foo", t = "bar"
输出: false输入: s = "paper", t = "title"
输出: true这道题可以用建两个Hashmap来做，一个s的，一个t的；key存字符，value存下标；每次put时，比较各自旧的value值（即之前的下标）是否相等，不等直接返回false，遍历一遍返回true。
注意到其实这题中的字符实际上是有限个（ASCII字符一共256个），而且字符的值可以用作索引，所以可以用数组（也是常用方法）；建一个512长度的数组（前256个位置用于s字符串，后256个位置用于t字符串），数组中存相应字符上一次出现的下标+1。
public boolean isIsomorphic(String s1, String s2) {
Map<Character, Integer> m1 = new HashMap<>();
Map<Character, Integer> m2 = new HashMap<>();
for(Integer i = 0; i < s1.length(); i++) {//注意这里只能用Integer
if(m1.put(s1.charAt(i), i) != m2.put(s2.charAt(i), i)) {
//这里put函数返回值：与 key 关联的旧value；如果 key 没有任何映射关系，则返回 null。
return false;
}
}
return true;
}
/*对于只能用Integer i=0，不能写成int i=0；属于java中Integer包装类中的一个知识，
由于Integer i 是一个对象，用！=比较时，比较的是不是同一个引用，不是比较的i的值等不等，int i每次自动生成对应的包装类时都新生成了不同的对象（即便i的值相等）。
那为什么有时却是可以的？因为当int i 的值为-128到127时，不会生成新的不同的对象，而是使用池中对应的对象，这时候int的值相等时，包装后的Integer都是同一个对象，所以就能用！=判断不等。
*/数组的解法：
public class Solution {
public boolean isIsomorphic(String s1, String s2) {
int[] m = new int[512];
for (int i = 0; i < s1.length(); i++) {
if (m[s1.charAt(i)] != m[s2.charAt(i)+256]) return false;
m[s1.charAt(i)] = m[s2.charAt(i)+256] = i+1;
}
return true;
}
}
/* m[s1.charAt(i)] = m[s2.charAt(i)+256] = i+1;
这一步为什么是i+1？因为数组中默认都是0，标记下标如果从0开始，不区分默认和后置的标记下标会出错；
例如：“aa”和“ab”
*/给定一种 pattern(模式) 和一个字符串 str ，判断 str 是否遵循相同的模式。
这里的遵循指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应模式。
输入: pattern = "abba", str = "dog cat cat dog"
输出: true输入:pattern = "abba", str = "dog cat cat fish"
输出: false这题跟同构字符串那题实际是一样的，不过parrern和str要进行匹配的类型不同了，一个是字符，一个是子字符串，所以不能用数组的方法了，用哈希表的方法做。
public boolean wordPattern(String pattern, String str) {
String[] words = str.split(" "); //将str以空格分割开存入string数组
if (words.length != pattern.length()) //长度不等直接退出
return false;
Map index = new HashMap();
//哈希表中存两种键值对 （Charact，Integer）和（String，Integer）之间互不影响
for (Integer i=0; i<words.length; ++i)
if (index.put(pattern.charAt(i), i) != index.put(words[i], i))
//put函数返回值为以前与key关联的value，映射以前包含一个该键的映射关系，则用指定值替换旧值
return false;
return true;
}
/*
遍历 在这里i被设置为Integer而不是int是因为如果设为int则要自动装箱，
而同一int值自动装箱后的生成的Integer在用==比较时不一定相等。
（只有在-128到127才等 The JVM is caching Integer values. == only works for numbers between -128 and 127）
*/你正在和你的朋友玩 猜数字（Bulls and Cows）游戏：你写下一个数字让你的朋友猜。每次他猜测后，你给他一个提示，告诉他有多少位数字和确切位置都猜对了（称为“Bulls”, 公牛），有多少位数字猜对了但是位置不对（称为“Cows”, 奶牛）。你的朋友将会根据提示继续猜，直到猜出秘密数字。
请写出一个根据秘密数字和朋友的猜测数返回提示的函数，用 A 表示公牛，用 B 表示奶牛。
请注意秘密数字和朋友的猜测数都可能含有重复数字
输入: secret = "1807", guess = "7810"
输出: "1A3B"
解释: 1 公牛和 3 奶牛。公牛是 8，奶牛是 0, 1 和 7。这里Bulls的统计比较容易，一次遍历比较就行；对于cows，除了Bulls外，只要secret中有的数字guess中也有，那么对应的这个数字的cows就是这个数字公共出现的个数，例如，除去Bulls不看，secret中有2个‘1’，guess中有1个‘1’，那么‘1’这个字符的cows就是1，再继续看其他数字把cows加起来。
这里需要统计每次数字出现的个数，要定义一些计数器，不妨建两个长度为10的数组来计数。
public String getHint(String secret, String guess) {
int temp = 0;
int bulls = 0;
int[] nums1 = new int[10]; //存secret中的除了能对应上的其他数字的个数 如nums[0]为secret中除了对应上的
//其余0的个数
int[] nums2 = new int[10]; //同上 存guess中的
for(int i = 0; i < secret.length(); i++){
char s = secret.charAt(i);
char g = guess.charAt(i);
if(s == g){
bulls++; //对应相等 bulls直接就加
}
else{
nums1[s - ‘0‘]++; //否则俩个数组相应位置上+1
nums2[g - ‘0‘]++;
}
}
int cows = 0;
for(int i = 0; i < 10; i++){
cows += Math.min(nums1[i], nums2[i]); //遍历一遍俩数组 cows每次加上两数组中相应数字公共出现的次数
}
String res = bulls + "A" + cows + "B";
return res;
}给定两个整数，分别表示分数的分子 numerator 和分母 denominator，以字符串形式返回小数。
如果小数部分为循环小数，则将循环的部分括在括号内。
输入: numerator = 1, denominator = 2
输出: "0.5"输入: numerator = 2, denominator = 1
输出: "2"输入: numerator = 2, denominator = 3
输出: "0.(6)"示例中的三种就是要考虑的所有情况。即能够整除，只有整数位，循环小数。这三种中只有整数位最好处理，有循环最最复杂；如何判断循环？有循环就意味着重复，所以，哈希表。
注意这里可能会有溢出的问题，所以将int转化为long
public String fractionToDecimal(int numerator, int denominator) {
if (numerator==0) return "0";
StringBuilder res=new StringBuilder();
res.append((numerator>0)^(denominator>0)?"-":"");
long num=Math.abs((long) numerator); //转成long防止溢出
long den=Math.abs((long)denominator);
res.append(num/den);
num=num%den;
if (num==0){
return res.toString(); //能整除没小数部分就返回就行
}
res.append("."); //否则有小数部分 先加个小数点
Map<Long,Integer> map=new HashMap<>(); //建哈希表存余数是关键
map.put(num,res.length()); //key是余数 value存的是下标，以便循环时插入（）
while (num!=0){
//判断余数是否为0 为零说明就除净了，在while中num也不总是存余数，也做被除数用，
//但一定是判断余数是否为零，while中的语句结构顺序很重要
num*=10; //类似列竖式做除法 余数乘10再除以除数
res.append(num/den);
num%=den;
if (map.containsKey(num)){
int index=map.get(num);
res.insert(index,"(");
res.append(")");
break;
}else {
map.put(num,res.length());
}
}
return res.toString();
}编写一个算法来判断一个数是不是“快乐数”。
一个“快乐数”定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为 1，那么这个数就是快乐数。
输入: 19
输出: true
解释:
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1这题和分数到小数有点类似，都是用哈希表判断重复数字进而判断循环。可以写一个数字求和的辅助函数，方法就是% ／这种。
public boolean isHappy(int n) {
Set<Integer> set=new HashSet<>();
int a;
while (set.add(n)){
a=qiuhe(n);
if (a==1){
return true;
}
else n=a;
}
return false;
}
public int qiuhe(int m){
int x,b=0;
while (m>0){
x=m%10;
b=b+x*x;
m=m/10;
}return b;
}统计所有小于非负整数 n 的质数的数量。
输入: 10
输出: 4
解释: 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。这题有一个经典算法，叫 埃拉托色尼筛选法（Sieve of Eratosthenes算法）
步骤如下：
（1）先把1删除（1既不是质数也不是合数）
（2）读取队列中当前最小的数2，然后把2的倍数删去
（3）读取队列中当前最小的数3，然后把3的倍数删去
（4）读取队列中当前最小的数5，然后把5的倍数删去
.......
（n）读取队列中当前最小的状态为true的数n，然后把n的倍数删去
这题呢，能用哈希表做，思路是将所有数存哈希表中，再把非质数remove掉，但会超时。
实际只需要建一个n长的boolean数组就行了。不知道这题为什么有哈希表的标签....
public int countPrimes(int n) {
boolean[] notPrime = new boolean[n];
int count = 0;
for (int i = 2; i < n; i++) {
if (notPrime[i] == false) {
count++;
for (int j = 2; i*j < n; j++) {
notPrime[i*j] = true;
}
}
}
return count;
}18.四数之和 (双指针)
94.二叉树中序遍历 （树）
136.只出现一次的数字（位运算）
274.H指数（sort 计数排序）
标签：输出 数字游戏 char arraylist paper col har 解法 哈希表
原文地址：https://www.cnblogs.com/10zhang/p/9316961.html
