【leetcode-映射】同构字符串/缺失的第一个正数/键盘行

给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。
每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

示例 1:
输入：s = “egg”, t = “add”
输出：true

示例 2：
输入：s = “foo”, t = “bar”
输出：false

示例 3：
输入：s = “paper”, t = “title”
输出：true

哈希表

class Solution {
    public boolean isIsomorphic(String s, String t) {
        return getString(s).equals(getString(t));
    }

    private String getString(String s) {
        Map<Character, Character> map = new HashMap<>();
        StringBuilder sb = new StringBuilder();
        char[] charArray = s.toCharArray();
        for (char c : charArray) {
            if (!map.containsKey(c))
                map.put(c, (char)('a' + map.size()));
            sb.append(map.get(c));
        }
        return sb.toString();
    }
}

class Solution {
    public boolean isIsomorphic(String s, String t) {
        Map<Character, Character> s2t = new HashMap<>();
        Map<Character, Character> t2s = new HashMap<>();
        int len = s.length();
        for (int i = 0; i < len; ++i) {
            char x = s.charAt(i), y = t.charAt(i);
            if ((s2t.containsKey(x) && s2t.get(x) != y) || (t2s.containsKey(y) && t2s.get(y) != x))
                return false;
            s2t.put(x, y);
            t2s.put(y, x);
        }
        return true;
    }
}

索引

class Solution {
    public boolean isIsomorphic(String s, String t) {
        int len = s.length();
        for (int i = 0; i < len; ++i) {
            char x = s.charAt(i), y = t.charAt(i);
            if (s.indexOf(x) != t.indexOf(y))
                return false;
        }
        return true;
    }
}

映射

class Solution {
    public boolean isIsomorphic(String s, String t) {
        int len = s.length();
        int sm[] = new int[128];
        int tm[] = new int[128];
        char sChars[] = s.toCharArray();
        char tChars[] = t.toCharArray();
        for(int i = 0; i < len; i++){
            if(sm[sChars[i]] != tm[tChars[i]])
                return false;
            sm[sChars[i]] = tm[tChars[i]] = i + 1;
        }
        return true;
    }
}

缺失的第一个正数

给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。

示例 1：
输入：nums = [1,2,0]
输出：3

示例 2：
输入：nums = [3,4,-1,1]
输出：2

示例 3：
输入：nums = [7,8,9,11,12]
输出：1

排序

排序后遍历

class Solution {
    public int firstMissingPositive(int[] nums) {
        int len = nums.length;
        if (len < 1)
            return 1;

        Arrays.sort(nums);
        int pos = -1;
        int left = 0, right = len - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == 1) {
                pos = mid;
                break;
            }
            if (nums[mid] < 1) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        if (pos == -1)
            return 1;
        for (int i = pos; i < len; i++) {
            if (i == len - 1)
                return nums[i] + 1;
            if (i == len - 1 || nums[i + 1] - nums[i] > 1)
                return nums[i] + 1;
        }
        return 1;
    }
}

原地哈希-标记

将数组视为哈希表。

• 将数组中所有小于等于 0 的数修改为 N+1；
• 遍历数组中的每一个数 x，它可能已经被打了标记，因此原本对应的数为 |x|。如果∣x∣∈[1,N]，那么我们给数组中的第∣x∣−1 个位置的数添加一个负号。注意如果它已经有负号，不需要重复添加；
• 在遍历完成之后，如果数组中的每一个数都是负数，那么答案是 N+1，否则答案是第一个正数的位置加 1。
  

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; ++i) {
            if (nums[i] <= 0)
                nums[i] = n + 1;
        }
        for (int i = 0; i < n; ++i) {
            int num = Math.abs(nums[i]);
            if (num <= n)
                nums[num - 1] = -Math.abs(nums[num - 1]);
        }
        for (int i = 0; i < n; ++i) {
            if (nums[i] > 0)
                return i + 1;
        }
        return n + 1;
    }
}

原地哈希-置换

将小于等于 N 的数放到对应的位置上。以[3, 4, -1, 1] 为例，恢复后的数组应当为 [1, -1, 3, 4]，因为2的位置上不是2，所以我们就可以知道缺失的数为 2。

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; ++i) {
            while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
                int temp = nums[nums[i] - 1];
                nums[nums[i] - 1] = nums[i];
                nums[i] = temp;
            }
        }
        for (int i = 0; i < n; ++i) {
            if (nums[i] != i + 1)
                return i + 1;
        }
        return n + 1;
    }
}

键盘行

给你一个字符串数组 words ，只返回可以使用在 美式键盘 同一行的字母打印出来的单词。键盘如下图所示。

美式键盘 中：
第一行由字符 “qwertyuiop” 组成。
第二行由字符 “asdfghjkl” 组成。
第三行由字符 “zxcvbnm” 组成。

示例 1：
输入：words = [“Hello”,“Alaska”,“Dad”,“Peace”]
输出：[“Alaska”,“Dad”]

示例 2：
输入：words = [“omk”]
输出：[]

示例 3：
输入：words = [“adsdf”,“sfd”]
输出：[“adsdf”,“sfd”]

映射

class Solution {
    public String[] findWords(String[] words) {
        String[] letters = new String[]{"qwertyuiop", "asdfghjkl", "zxcvbnm"};
        int[] map = new int[128];
        for (int i = 0; i < letters.length; i++) {
            for (int j = 0; j < letters[i].length(); j++) {
                map[letters[i].charAt(j)] = i;
                map[letters[i].charAt(j) - 32] = i;
            }
        }

        List<String> result = new ArrayList<>();
        for (int i = 0; i < words.length; i++) {
            int last = map[words[i].charAt(0)], j = 1;
            for (; j < words[i].length(); j++) {
                if (map[words[i].charAt(j)] != last)
                    break;
            }
            if (j == words[i].length())
                result.add(words[i]);
        }
        return result.toArray(new String[0]);
    }
}