class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        int[] hash1 = new int[26];
        int[] hash2 = new int[26];
        int sl = s.length();
        int pl = p.length();
        List<Integer> ret = new ArrayList<>();
        for (int i = 0; i < pl; i++) {
            hash1[p.charAt(i) - 'a']++;
        }
        /*
        for (int j = 0; j < sl; j++) {
            hash2[s.charAt(j) - 'a']++;
            if (j >= pl - 1) {
                if (cheak(hash1, hash2)) {
                    ret.add(j - pl + 1);
                }
                hash2[s.charAt(j - pl + 1) - 'a']--;
            }
        }*/
        for (int left = 0, right = 0, count = 0; right < sl; right++) {
            if (++hash2[s.charAt(right) - 'a'] <= hash1[s.charAt(right) - 'a']) {
                count++;
            }
            if (right >= pl) {
                hash2[s.charAt(left) - 'a']--;
                if (hash2[s.charAt(left) - 'a'] < hash1[s.charAt(left) - 'a']) {
                    count--;
                }
                left++;
            }
            if (count == pl) {
                ret.add(left);
            }
        }
        return ret;
    }

    public static boolean cheak(int[] hash1, int[] hash2) {
        for (int i = 0; i < 26; i++) {
            if (hash1[i] != hash2[i]) {
                return false;
            }
        }
        return true;
    }
    // 我写代码是真的费劲啊,代码思路是一样的,老师写的就很简洁
}

class Solution {
    public List<Integer> findAnagrams(String ss, String pp) {
        List<Integer> ret = new ArrayList<Integer>();
        char[] s = ss.toCharArray();

        char[] p = pp.toCharArray();
        int[] hash1 = new int[26]; // 统计字符串 p 中每⼀个字符出现的个数
        for (char ch : p)
            hash1[ch - 'a']++;
        int[] hash2 = new int[26]; // 统计窗⼝中每⼀个字符出现的个数
        int m = p.length;
        for (int left = 0, right = 0, count = 0; right < s.length; right++) {
            char in = s[right];
            // 进窗⼝ + 维护 count
            if (++hash2[in - 'a'] <= hash1[in - 'a'])
                count++;
            if (right - left + 1 > m) // 判断
            {
                char out = s[left++];
                // 出窗⼝ + 维护 count
                if (hash2[out - 'a']-- <= hash1[out - 'a'])
                    count--;
            }
            // 更新结果
            if (count == m)
                ret.add(left);
        }
        return ret;
    }
}

题目思路:
滑动窗口遍历数组,这个窗口的长度是固定的,构造两个hash表,一个用于描述String p,一个用于藐视String s 的字串,比较比较两个hash表判断子串是否是字符串p的异位词。时间复杂度为26*O(N)；
算法优化:
在双指针遍历的时候引入变量count代表有效字符数,譬如:遍历到ccb时的有效字符数为2,遍历到ccba时的需要出窗口,即cba有效字符数3恰好等于字符串p的长度,此时子串就是p的异位词。

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> ret = new ArrayList<>();
        Map<String, Integer> hash1 = new HashMap<>();

        int sl = s.length();
        int wl = words.length;
        int len = words[0].length();
        for (int i = 0; i < wl; i++) {
            hash1.put(words[i], hash1.getOrDefault(words[i], 0) + 1);
        }
        for (int i = 0; i < len; i++) {
            Map<String, Integer> hash2 = new HashMap<>();
            for (int left = i, right = i, count = 0; right <= sl - len; right += len) {
                String in = s.substring(right, right + len);
                hash2.put(in, hash2.getOrDefault(in, 0) + 1);// 进窗口
                if (hash2.get(in) <= hash1.getOrDefault(in, 0)) {
                    count++;
                }
                if (right - left >= len * wl) {
                    String out = s.substring(left, left + len);
                    hash2.put(out, hash2.get(out) - 1);
                    if (hash2.get(out) < hash1.getOrDefault(out, 0)) {
                        count--;
                    }
                    left += len;
                }
                if (count == wl) {
                    ret.add(left);
                }
            }
        }

        return ret;
    }
}

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> ret = new ArrayList<Integer>();
        // 保存字典中所有单词的频次
        Map<String, Integer> hash1 = new HashMap<String, Integer>();
        for (String str : words)
            hash1.put(str, hash1.getOrDefault(str, 0) + 1);
        int len = words[0].length(), m = words.length;
        for (int i = 0; i < len; i++) // 执⾏次数
        {
            // 保存窗⼝内所有单词的频次
            Map<String, Integer> hash2 = new HashMap<String, Integer>();
            for (int left = i, right = i, count = 0; right + len <= s.length(); right += len) {
                // 进窗⼝ + 维护 count
                String in = s.substring(right, right + len);
                hash2.put(in, hash2.getOrDefault(in, 0) + 1);
                if (hash2.get(in) <= hash1.getOrDefault(in, 0))
                    count++;
                // 判断
                if (right - left + 1 > len * m) {
                    // 出窗⼝ + 维护 count
                    String out = s.substring(left, left + len);
                    if (hash2.get(out) <= hash1.getOrDefault(out, 0))
                        count--;
                    hash2.put(out, hash2.get(out) - 1);
                    left += len;
                }
                // 更新结果
                if (count == m)
                    ret.add(left);
            }
        }
        return ret;
    }
}

包含的细节还挺多的:
老方法:两个hash表去分别表示子串和words,然后遍历两个hash表来判断子串是否串联了所有单词
优化之后:在遍历的字符串的时候借用count记录有效但此时,随着双指针的移动维护count,若count等于words中单词了数量是说明双指针子串包含了words中的所有单词。

class Solution {
    public String minWindow(String ss, String tt) {
        char[] t = tt.toCharArray();
        char[] s = ss.toCharArray();
        int tl = t.length;
        int sl = s.length;
        int[] hash1 = new int[128];
        int[] hash2 = new int[128];
        int minlen = sl+1;
        int begin = 0;
        for (int i = 0; i < tl; i++) {
            hash1[t[i]]++;
        }
        for (int left = 0, right = 0, count = 0; right < sl; right++) {
            // 进窗口,维护有效字符数
            if (++hash2[s[right]] <= hash1[s[right]]) {
                count++;
            }
            while (count == tl && left <= right) {
                if(right - left + 1 < minlen){
                    minlen = right - left + 1;
                    begin = left;
                }
                if (--hash2[s[left]] < hash1[s[left]]) {
                    count--;
                }
                left++;
            }
        }
        if (minlen==sl+1)
            return "";
        return ss.substring(begin,begin+minlen);
        // 注意不要在循环里面使用substring(),会增加时间复杂度
    }

}
// count统计的是t中字符的个数

class Solution {
    public String minWindow(String ss, String tt) {
        char[] s = ss.toCharArray();
        char[] t = tt.toCharArray();
        int[] hash1 = new int[128]; // 统计字符串 t 中每⼀个字符的频次
        int kinds = 0; // 统计有效字符有多少种
        for (char ch : t)
            if (hash1[ch]++ == 0)
                kinds++;
        int[] hash2 = new int[128]; // 统计窗⼝内每个字符的频次
        int minlen = Integer.MAX_VALUE, begin = -1;
        for (int left = 0, right = 0, count = 0; right < s.length; right++) {
            char in = s[right];
            if (++hash2[in] == hash1[in])
                count++; // 进窗⼝ + 维护 count
            while (count == kinds) // 判断条件
            {
                if (right - left + 1 < minlen) // 更新结果
                {
                    minlen = right - left + 1;
                    begin = left;
                }
                char out = s[left++];
                if (hash2[out]-- == hash1[out])
                    count--; // 出窗⼝ + 维护 count
            }
        }
        if (begin == -1)
            return new String();
        else
            return ss.substring(begin, begin + minlen);
    }
}
// count统计的是t字符的种类,我感觉这个写法并没有优化多少,而且有点稍微难理解

双指针滑动窗口本质上是对暴力解法的优化,暴力解法中往往也是两个指针,以left指针为起点,right指针从left处开始对数组进行扫描,之后left右移,right回到left处再次开始扫描,显然这种解法的时间复杂度是O(N^2)
优化思路:right可以不需要回撤,双指针始终向右移,可以利用数组的单调性等来实现。这样的时间复杂度就是O(N)了。

class Solution {
    public int search(int[] nums, int target) {
        // 1:都读题目
        // 数组升序,严格升序不存在 1 2 2 3 这种情况
        // 数组具有"二段性"
        int left = 0;
        int right = nums.length - 1;
        int index = 0;
        while (left <= right) {
            index = left + (right- left)/2; //防止溢出
            if (nums[index] > target) {
                right = index - 1;
            } else if (nums[index] < target) {
                left = index + 1;
            } else {
                return index;
            }
        }
        return -1;
    }
}

朴素二分查找

class Solution {
    public int[] searchRange(int[] nums, int target) {
        // 1、读题目
        // 非递减数列 存在形如 1 2 2 3
        int left = 0, right = nums.length - 1; 
        int[] ret = new int[2];
        ret[0]=-1;ret[1]=-1;
        if(nums.length==0) return ret;
        // 左端点
        while (left < right) {
            // mid中间偏左
            int mid = left + (right - left) / 2; 
            if (nums[mid] < target) {
                left = mid+1;
            }else{
                //因为nums[mid]>=target,而nums[mid-1]有可能小于target，
                //就不会是最左边目标值了，所以移动右指针为right = mid; 
                right = mid; 
            }
        }
        if(nums[left] != target) return ret;
        else ret[0]=right;
        // 右端点
        left = right;
        right = nums.length-1;
        while (left < right) {
            // mid中间偏右
            int mid = left + (right - left+1) / 2; 
            if (nums[mid] > target) {
                right = mid-1;
            }else{
                left = mid; 
            }
        }
        ret[1]=left;
        return ret;
    }
}

二分查找最左边或最右边的目标值,朴素的二分查找传到目标值以后就可以返回退出循环了,所以结束条件是while(left<=right),但是对于查找位于最左变或最右边的目标则不一样,当nums[mid]==target时循环并不能结束,以查找最左边目标值为例:
重点:

while (left < right) {
    // mid中间偏左
    int mid = left + (right - left) / 2; 
    if (nums[mid] < target) {
        left = mid+1;
    }else{
        //因为nums[mid]>=target,而nums[mid-1]有可能小于target，
        //就不会是最左边目标值了，所以移动右指针为right = mid; 
        right = mid; 
    }
}

while (left < right) {
    // mid中间偏右
    int mid = left + (right - left+1) / 2; 
    if (nums[mid] > target) {
        right = mid-1;
    }else{
        left = mid; 
    }
}
// 循环结束时

class Solution {
    public int searchInsert(int[] nums, int target) {
        int n = nums.length;
        int left = 0;
        int right = n - 1;
        int mid = 0;
        if(target>nums[right]) return n;
        //吴老师的二分法是分为两个分支,将后两个合并,while循环不会提前结束,
        //虽然比我写的行数少且简洁,但提前结束循环理论上来说时间耗时更小一些,
        //但是圈复杂度比较高

        //补充：我这样写之所以能对是因为数组是严格递增的，
        //若不是严格递增的会因为没有找到最右侧目标值而测试失败
        //吴老师给的模板才是通用的，对于非递减数组
        //或数组中无目标值(此时双指针会停在最近目标值的左侧或者右侧)都可以适用
        //吴老师yyds
        while(left<right){
            mid = left + (right - left)/2;
            if(nums[mid]<target){
                left=mid+1;
            }else if(target<nums[mid]){
                right=mid;
            }else{
                break;
            }
        }
        if(left<right) return mid;
        return left;
    }
} 
// 这也是一个二分查找最左目标值的问题
// 还是老老实实用吴老师的两分支模板吧！

// 我写的
class Solution {
    public int mySqrt(int x) {
        // 求算数平方根的整数部分
        // 二分法

        long left = 0;
        long right = x;
        if (x == 0)
            return x;
        while (left < right) {
            long mid = left + (right - left) / 2;
            if (mid * mid > x) {
                right = mid;
            } else if (mid * mid < x) {
                left = mid + 1;
            } else {
                return (int) mid;
            }
        }
        if (right * right == x)
            return (int) right;
        return (int) right - 1;
    }
}

// 吴老师写的
class Solution {
    public int mySqrt(int x) {
        // 找最右侧目标值
        if (x < 1)
            return 0;
        long left = 1, right = x;
        while (left < right) {
            long mid = left + (right - left + 1) / 2;
            if (mid * mid <= x)
                left = mid;
            else
                right = mid - 1;
        }
        return (int) left;
    }
}

怎么说呢,这是一个典型的最在右侧目标值的问题,吴老师的模板yyds,好好理解一下。

class Solution {
    public int peakIndexInMountainArray(int[] arr) {
        int n = arr.length;
        int left=0;
        int right = n-1;
        while(left<right){
            int mid = left+(right-left+1)/2;
            if(arr[mid]>arr[mid-1]){
                left=mid;
            }else {
                right=mid-1;
            }
        }
        return left;
    }
}
//用吴老师的模板写，简简单单

class Solution {
    public int findPeakElement(int[] nums) {
        int n = nums.length;
        int left = 0;
        int right = n - 1;
        while(left<right){
            int mid = left + (right - left)/2;
            if(nums[mid]>nums[mid+1]){
                right=mid;
            }else {
                left=mid+1;
            }
        }
        return left;
    }
}

二分算法适用于具有二段性的场景，本题的难点就在于分析出二段在哪里
对于数组某一位置i,如果nums[i]>nums[i+1]则[left,i]区间一定存在高峰，反之[i+1,right]区间一定存在高峰。

如图所示，以D点为参照物数组具有二段性。
如果nums[mid]>nums[right]则最低点一定在[mid+1,right]区间
如果nums[mid]<nums[right]则最低点一定在[left,mid]区间
根据题意不存在nums[mid]==nums[right]

class Solution {
    public int findMin(int[] nums) {
        int n=nums.length;
        int left=0;
        int right=n-1;
        while(left<right){
            //如果mid偏右就会导致当左右指针相邻是陷入死循环
            //所以mid要写成偏左的形式
            int mid = left+(right-left)/2;
            if(nums[mid]>nums[right]){
                left=mid+1;
            }else{
                right=mid;
            }
        }
        return nums[left];
    }
}

class Solution {
    public int takeAttendance(int[] records) {
        int n = records.length;
        int left = 0;
        int right = n - 1;
        if(records[right]==right) return n;
        while(left<right){
            int mid = left + (right-left)/2;
            if(mid==records[mid]){
                left=mid+1;
            }else{
                right=mid;
            }
        }
        return right;
    }
}
//数组具有二段性：如果records[mid]==mid,说明mid之前的名单都是正常的，缺失的数位于mid之后

0^1^1^2^2^3^4^4^5^5=3

0+1+2+3+4=5*(4+0)/2

利用一个长度为n+1的哈希表，将名单放入哈希表，为零的位置就是缺失的名单

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int b = in.nextInt();
        int[] arr = new int[a];
        long[] sum = new long[a+1];
        for(int i=0;i<a;i++){
            arr[i]=in.nextInt();
            //★★
            sum[i+1]=sum[i]+arr[i];
        }
        while(b>0){
            int i=in.nextInt();
            int j=in.nextInt();
            // 使用一维前缀和数组
            System.out.println(sum[j]-sum[i-1]);
            b--;
        }
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int q = in.nextInt();
        int[][] arr = new int[n][m];
        long[][] dp = new long[n+1][m+1];
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                arr[i][j] = in.nextInt();
                // 构造二位前缀和数组
                dp[i+1][j+1] = dp[i][j+1]+dp[i+1][j]+arr[i][j]-dp[i][j];
            }
        }
        for(int i=0;i<q;i++){
            int x1=in.nextInt();
            int y1=in.nextInt();
            int x2=in.nextInt();
            int y2=in.nextInt();
            // 使用二位前缀和数组
            System.out.println(dp[x2][y2]+dp[x1-1][y1-1]-dp[x1-1][y2]-dp[x2][y1-1]);
        }
    }
}

class Solution {
    public int pivotIndex(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n+1];
        // 构造前缀和数组
        for(int i=1;i<=n;i++){
            dp[i]=dp[i-1]+nums[i-1];
        }
        // 构造后缀和数组（可有可无，频繁用到后缀和的话也可以提前构造出来）
        
        // 数组不具有二段性，中心下标随机分布，所以老老实实遍历好了
        for(int i=0;i<n;i++){
            if(dp[i]==dp[n]-dp[i+1]){
                return i;
            }
        }
        return -1;
    }
}

class Solution {
    public int[] productExceptSelf(int[] nums) {
        //读题目，题目要求不能使用触发
        //该位置的前缀积乘以后缀积
        int n = nums.length;
        //构造前置积
        int[] f = new int[n];
        int[] g = new int[n];
        f[0]=g[0]=nums[0];
        f[n-1]=g[n-1]=nums[n-1];
        for(int i=1;i<n;i++){
            f[i]=f[i-1]*nums[i];
        }
        for(int i=n-2;i>0;i--){
            g[i]=g[i+1]*nums[i];
        }
        int[] ret = new int[n];
        ret[0]=g[1];
        ret[n-1]=f[n-2];
        for(int i=1;i<n-1;i++){
            ret[i]=f[i-1]*g[i+1];
        }
        return ret;
        // 原数组，前缀数组，后缀数组
        // 边界值
        // 数值之间下标的对应关系
        // 淦！！！
    }
}

class Solution {
    public int[] productExceptSelf(int[] nums) {
        // lprod 表⽰：[0, i - 1] 区间内所有元素的乘积
        // rprod 表⽰：[i + 1, n - 1] 区间内所有元素的乘积
        int n = nums.length;
        int[] lprod = new int[n];
        int[] rprod = new int[n];
        lprod[0] = 1;
        rprod[n - 1] = 1;

        // 预处理前缀积以及后缀积
        for (int i = 1; i < n; i++)
            lprod[i] = lprod[i - 1] * nums[i - 1];
        for (int i = n - 2; i >= 0; i--)
            rprod[i] = rprod[i + 1] * nums[i + 1];

        // 处理结果数组
        int[] ret = new int[n];
        for (int i = 0; i < n; i++)
            ret[i] = lprod[i] * rprod[i];
        return ret;
    }
}

class Solution {
    public int subarraysDivByK(int[] nums, int k) {
        // 同余定理
        // (a-b)%9==0，则a%9=b%9 
        // 若存在j<i、nums[i]%k==b、num[j]%k==b,则子数组[j,i]元素和为k的倍数
        int n = nums.length;
        Map<Integer, Integer> hash = new HashMap<>();
        hash.put(0,1);
        int sum=0;
        int ret=0;
        for(int x:nums){
            sum+=x;
            int in = ((sum%k)+k)%k;
            ret+=hash.getOrDefault(in,0);
            hash.put(in,hash.getOrDefault(in,0)+1);
        }
        return ret;
    }
}

O(N^3):暴力枚举，每一个子数组，使用O(N)的方法判断这个子数组是否都满足提要求

O(N^2):构造前缀和数组，暴力枚举每一个子数组，利用前缀和求的子数组中元素之和，进而仅需O(1)的时间复杂度就能判断子数组是否满足题目要求

O(N*logN):并不需暴力枚举每一个子数组，若两个前缀和数组对k的余数相同，根据同余定理可得两前缀和数组相减得到的子数组是k的倍数，所以在遍历数组的时候统计每一种余数出现的次数，就可以直接得出以下一位置为结尾的满足题意的子数组的个数。

class Solution {
    public int findMaxLength(int[] nums) {
        // 若[left,right],则 right-left+1 == 子数组元素和*2
        int n = nums.length;
        Map<Integer,Integer> hash = new HashMap<>(); // 下标，0,1数量差
        hash.put(0,-1);
        int sum=0;  
        int max=0;
        for(int i=0;i<n;i++){
            sum+=nums[i];
            int cha = i+1-2*sum;
            if(hash.containsKey(cha)){
                max=Math.max(max,i-hash.get(cha));
            }else{
                hash.put(cha,i);
            }
        }  
        return max;
    }
}

class Solution {
    public int findMaxLength(int[] nums) {
        Map<Integer, Integer> hash = new HashMap<Integer, Integer>();
        hash.put(0, -1); // 默认存在⼀个前缀和为 0 的情况
        int sum = 0, ret = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += (nums[i] == 0 ? -1 : 1); // 计算当前位置的前缀和
            if (hash.containsKey(sum))
                ret = Math.max(ret, i - hash.get(sum));
            else
                hash.put(sum, i);
        }
        return ret;
    }
}
// 把0当成-1，问题就变成了求元素和为0的最大子数组长度
// 和之前求元素和为0的子数组的个数不同的是，Map<Integer,Integer>里面存的是<前缀和，最小下标>
// 之前存的是<前缀和，满足条件的子数组的个数>
// 我的代码和吴老师的思路本质上是一样的

class Solution {
    public int[][] matrixBlockSum(int[][] mat, int k) {
        int m = mat.length;
        int n = mat[0].length;
        int[][] dp = new int[m+1][n+1];
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                dp[i][j]=dp[i][j-1]+dp[i-1][j]-dp[i-1][j-1]+mat[i-1][j-1];
            }
        }
        int[][] ret = new int[m][n];
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                int x1= i-k>1?i-k:1;
                int y1= j-k>1?j-k:1;
                int x2= i+k<m?i+k:m; // 边界值处理,一开始没写对debug之后发现的
                int y2= j+k<n?j+k:n; // 边界值处理
                ret[i-1][j-1]=dp[x2][y2]-dp[x1-1][y2]-dp[x2][y1-1]+dp[x1-1][y1-1];
            }
        }
        return ret;
    }
}

// 抽时间写篇debug的笔记

// 解题思路：用位图代替哈希表
class Solution {
    public boolean isUnique(String astr) {
        char[] s = astr.toCharArray();
        int bitMap = 0;
        for (int i = 0; i < s.length; i++) {
            int x = s[i] - 'a';
            if (((bitMap >> x) & 1) == 1) {
                return false;
            }else{
                bitMap |= (1 << x);
            }
        }
        return true;
    }
}

// 1、使用int bitMap = 0;充当哈希表
// 2、使用 (bitMap>>x)&1 的值判断是字母否出现过
// 3、使用 bitMap |= (1 << x); 标记该字母出现过

class Solution {
    public int missingNumber(int[] nums) {
        int ret=nums.length;
        for(int i=0;i<nums.length;i++){
            ret^=i^nums[i];
        }
        return ret;
    }
}
// 借助异或运算的规律该寻找丢失的数字
// a^a^b^b^c=c
// a^a=0
// a^0=a

class Solution {
    public int getSum(int a, int b) {
        int carry =0;
        do{
            carry=(a&b)<<1;
            a=a^b;
            b=carry;
        }while(carry!=0);
        return a;
    }
    // 错误写法
    // public int getSum(int a, int b) {
    //     int carry =0;
    //     do{
    //         carry=(a&b)<<1;
    //         a=a^b;
    //         b=carry;
    //     }while(carry>=0);  // 进位有可能是负数
    //     return a;
    // }
}
// 算法原理：a+b = (a^b) + (a&b)<<1 循环进行操作直到进位等于0，就避免了使用加减法。
// 数字的原码，补码，反码

• 原码：用最高位表示符号位,其余位表示数值。例如, +5 用 0b0101 表示,而 -5 用 0b1101 表示。这是最简单直观的表示方法。
• 反码：正数的反码与原码相同,负数的反码是将原码的数值位按位取反(0变1,1变0),符号位不变。例如, +5 的反码是 0b0101,而 -5 的反码是 0b1010。
• 补码：正数的补码与原码相同,负数的补码是在该数的反码的基础上加1。例如, +5 的补码是 0b0101,而 -5 的补码是 0b1011。

补码的主要优点是:

• 加法和减法统一为加法运算,即可用同样的加法电路实现加法和减法。
• 0有唯一的表示形式,即 0b0000。而在原码中,+0 和 -0 有两种表示形式。

所以在计算机中,通常会采用补码来表示有符号整数。这样可以简化电路设计,提高运算效率。

如图所示：将数组中所有数的第i位比特位(0<=i<32)的值求和取余的结果恰好等于那个只出现了一次的数字的第i位比特位，求出该数字的32个比特位即可找到这个只出现了一次的数字。

class Solution {
    public int singleNumber(int[] nums) {
        // 算法原理
        int ret = 0;
        for (int i = 0; i < 32; i++) {
            int sum = 0;
            for (int x : nums) {
                sum += (x >> i) & 1;
            }
            if (sum % 3 == 1) {  // 将第i位比特位置位1
                ret |= (1 << i);
            } else { // // 将第i位比特位置位0（初始化的时候本来就是0，所也可以不做处理）
                ret &= (~(1 << i));
            }
        }
        return ret;
    }
}

算法原理：

class Solution {
    public int[] missingTwo(int[] nums) {
        // 1、将nums中的数字以及1~N异或
        // 得到temp=a^b,也就是缺失的两个数的异或
        // 因为a!=b,所以temp!=0
        int N = nums.length + 2;
        int temp = 0;
        for (int x : nums)
            temp ^= x;
        for (int i = 1; i <= N; i++)
            temp ^= i;
        // 2、因为temp!=0,所以存在某个比特位等于1，确定这个比特位的位置index
        temp = temp & (-temp);
        int index = 0;
        while (true) {
            if ((temp >> index) == 1)
                break;
            index++;
        }
        // 3、将所有数分为两类，即第index位比特位为1的分为一类，为0的分为一类
        // 此时缺失的两个数字会被分开，在这两个类数中只有a,b是单独存在的，其他数都是两个
        // 分别将两类数进行异或得到的两值就是缺失的两个数字。
        int[] ret = new int[2];
        for (int x : nums) {
            if (((x >> index) & 1) == 1)
                ret[0] ^= x;
            else
                ret[1] ^= x;
        }
        for (int i = 1; i <= N; i++) {
            if (((i >> index) & 1) == 1)
                ret[0] ^= i;
            else
                ret[1] ^= i;
        }
        return ret;
    }
}

class Solution {
    public String modifyString(String s) {
        char[] chars = s.toCharArray();
        int n = chars.length;
        if(n==1){
            if(chars[0]=='?'){
                return "a";
            }else{
                return s;
            }
        }
        if(chars[0]=='?'){
            if(chars[1]=='?'){
                chars[0]='a';
            }else if(n>1){
                chars[0]=(char)((chars[1]-'a'+1)%26+'a');
            }
        }
        for(int i=1;i<n-1;i++){
            if(chars[i]=='?'){
                chars[i]=getChar(chars[i-1],chars[i+1]);  
            }
        }
        if(chars[n-1]=='?')
            chars[n-1]=getChar(chars[n-2],' ');
        return new String(chars);
    }
    public static char getChar(char c1,char c2){
        char ret=' ';
        for(int i=0;i<26;i++){
            ret = (char)('a'+i);
            if(ret!=c1&&ret!=c2){
                return ret;
            }
        }
        return ret;
    }
}
// 写的好丑！！！

class Solution {

    public String modifyString(String ss) {
        char[] s = ss.toCharArray();
        int n = s.length;
        for (int i = 0; i < n; i++) {
            if (s[i] == '?') // 替换
            {
                for (char ch = 'a'; ch <= 'z'; ch++) {
                    if ((i == 0 || ch != s[i - 1]) && (i == n - 1 || ch != s[i + 1])) {
                        s[i] = ch;
                        break;
                    }
                }
            }
        }
        return String.valueOf(s);
    }
}
// 优雅永不过时！！

class Solution {
    public int findPoisonedDuration(int[] timeSeries, int duration) {
        int n = timeSeries.length;
        int time=0;
        int t=0;
        int sum=0;
        int left=-1;
        int right=-1;
        while(time<timeSeries[n-1]){
            if(time==timeSeries[t]){
                // 攻击，刷新毒区
                left = timeSeries[t];
                right = timeSeries[t]+duration-1;
                // t移动到下一次大于本次的攻击时间                
                t++;
                while(t<n&&timeSeries[t]==timeSeries[t-1]){
                    t++;
                }
            }
            if(left<=time && time<=right){
                sum++;
            }
            time++;
        }
        return sum+duration;
    }
}v

class Solution {
    public int findPoisonedDuration(int[] timeSeries, int duration) {
        if (duration == 0)
            return 0;
        int n = timeSeries.length;
        int sum=0;
        for (int t = 0; t < n-1; t++) {
            if(timeSeries[t]+duration-1<timeSeries[t+1]){
                sum+=duration;
            }else{
                sum+=timeSeries[t+1]-timeSeries[t];
            }
        }
        return sum+duration;
    }
}

class Solution {
    public String convert(String ss, int numRows) {
        if(numRows==1) return ss;
        char[] s = ss.toCharArray();
        int length = s.length;
        int m = numRows;
        int n = length;
        char[][] arr = new char[m][n];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                arr[i][j]=' ';
            }
        }
        int index=0;
        int i=0;
        int j=0;
        while(index<length){
            // 竖着的
            int a=0;
            while( a++<numRows && index<length){
                arr[i++][j]=s[index++];
            }
            i--;
            // 斜着的
            a=0;
            while(a++<numRows-2&&index<length){
                arr[--i][++j]=s[index++];
            }
            i--;j++;
        }
        index=0;
        for(i=0;i<m;i++){
            for(j=0;j<n;j++){
                if(arr[i][j]!=' '&&index<length){
                    s[index++]=arr[ii][jj];
                }
            }
        }
        return new String(s);
    }
}

class Solution {
    public String convert(String s, int numRows) {
        // 处理⼀下边界情况
        if (numRows == 1)
            return s;

        int d = 2 * numRows - 2, n = s.length();
        StringBuilder ret = new StringBuilder();
        // 1. 处理第⼀⾏
        for (int i = 0; i < n; i += d)
            ret.append(s.charAt(i));
        // 2. 处理中间⾏
        for (int k = 1; k < numRows - 1; k++) // 依次枚举中间⾏
        {
            for (int i = k, j = d - i; i < n || j < n; i += d, j += d) {
                if (i < n)
                    ret.append(s.charAt(i));
                if (j < n)
                    ret.append(s.charAt(j));
            }
        }

        // 3. 处理最后⼀⾏
        for (int i = numRows - 1; i < n; i += d)
            ret.append(s.charAt(i));
        return ret.toString();
    }
}

这哪是模拟题呀，这简直是数学题找规律呀！！！

class Solution {
    public String countAndSay(int n) {
        String s = "1";
        for(int i=1;i<n;i++){
            s=RLE(s);
        }
        return s;
    }
    public static String RLE(String ss){
        if(ss==null || ss.length()==0) return ss;
        StringBuilder ret = new StringBuilder();
        char[] s = ss.toCharArray();
        int n = s.length;
        int num=0;
        int i=0;
        while(i<n){
            while(i+1<n&&s[i]==s[i+1]){
                num++;
                i++;
            }
            ret.append(num+1);
            ret.append(s[i]);
            i++;
            num=0;
        }
        return ret.toString();
    }
}

class Solution {
    public String countAndSay(int n) {
        String ret = "1";
        for (int i = 1; i < n; i++) // 解释 n - 1 次 ret 即可
        {
            StringBuilder tmp = new StringBuilder();
            int len = ret.length();
            for (int left = 0, right = 0; right < len;) {
                while (right < len && ret.charAt(left) == ret.charAt(right))
                    right++;
                tmp.append(Integer.toString(right - left));
                tmp.append(ret.charAt(left));
                left = right;
            }
            ret = tmp.toString();
        }
        return ret;
    }
}
// 双指针:开始是left、right指向同一位置，然后right向右移动知道s[left]!=s[right],压缩。
// 然后left指针右移到right，重复上述操作压缩整个字符串
// 秀啊！！！

class Solution {
    public int minNumberOfFrogs(String croakOfFrogs) {
        // c.num>r.num>o.num>a.num>k.num
        // c r o a k
        // 0 1 2 3 4
        int[] hash = new int[5];
        char[] s = croakOfFrogs.toCharArray();
        int len = s.length;
        int num=0;
        for (char chr : s) {
            if(chr=='c'){
                if(hash[4]>0){
                    hash[4]--;    
                }
                hash[0]++;
            }else if(chr=='r'&&hash[0]>0){
                hash[0]--;
                hash[1]++;
            }else if(chr=='o'&&hash[1]>0){
                hash[1]--;
                hash[2]++;
            }else if(chr=='a'&&hash[2]>0){
                hash[2]--;
                hash[3]++;
            }else if(chr=='k'&&hash[3]>0){
                hash[3]--;
                hash[4]++;
            }else{
                return -1;
            }
        }
        for(int i=0;i<4;i++){
            if(hash[i]!=0)
                return -1;
        }
        return hash[4];
    }
}

class Solution {
    public int minNumberOfFrogs(String c) {
        char[] croakOfFrogs = c.toCharArray();
        String t = "croak";
        int n = t.length();
        int[] hash = new int[n]; // 数组模拟哈希表
        Map<Character, Integer> index = new HashMap<>(); // [x, x这个字符对应的下标
        for (int i = 0; i < n; i++)
            index.put(t.charAt(i), i);
        for (char ch : croakOfFrogs) {
            if (ch == t.charAt(0)) {
                if (hash[n - 1] != 0)
                    hash[n - 1]--;
                hash[0]++;
            } else {
                int i = index.get(ch);
                if (hash[i - 1] == 0)
                    return -1;
                hash[i - 1]--;
                hash[i]++;
            }
        }
        for (int i = 0; i < n - 1; i++)
            if (hash[i] != 0)
                return -1;

        return hash[n - 1];
    }
}
// 蛙声是五个字母就是五个if-else，所以需要一个通用的方法
// 优雅永不过时！

class Solution {
    public void sortColors(int[] nums) {
        int n = nums.length, i = -1,j = -1,k = 0;
        while (k < n) {
            if (nums[k] == 0) {
                i++;j++;
                int temp = nums[k];
                nums[k] = nums[j];
                nums[j] = nums[i];
                nums[i] = temp;
            }else if(nums[k]==1){
                j++;
                int temp = nums[k];
                nums[k]=nums[j];
                nums[j]=temp;
            }
            k++;
        }
    }
}
// 000111122200210201201
//   i   j   k

class Solution {
    public void swap(int[] nums, int i, int j) {
        int t = nums[i];
        nums[i] = nums[j];
        nums[j] = t;
    }
    public void sortColors(int[] nums) {
        int left = -1, right = nums.length, i = 0;
        while (i < right) {
            if (nums[i] == 0)
                swap(nums, ++left, i++);
            else if (nums[i] == 1)
                i++;
            else
                swap(nums, --right, i);
        }
    }
}
// 吴老师代码

class Solution {
    // 快速排序
    public int[] sortArray(int[] nums) {
        quickSort(nums, 0, nums.length - 1);
        return nums;
    }
    public static void quickSort(int[] nums, int l, int r) {
        if (l >= r) return;
        int key = nums[l + (r - l) / 2];// 使用随机数好一点
        key = nems[new Random().nextInt(r-l+1)+l];
        int left=l-1;
        int right=r+1;
        int k=l;
        while(k<right){
            if(nums[k]<key){
                swap(nums,++left,k++);
            }else if(nums[k]>key){
                swap(nums,--right,k);
            }else{
                k++;
            }
        }
        quickSort(nums, l,left);
        quickSort(nums,right,r);
    }
    public static void swap(int[] nums,int x,int y){
        int temp =nums[x];
        nums[x]=nums[y];
        nums[y]=temp;
    }
}
// 选择一个基数key,将数组分为三块:{nums[i]<key}{nums[i]==key}{nums[i]>key}
// 然后对左右两块递归调用排序

分治排序思想：选择一个基数key,调整数组将小于key的元素移动到key的右侧，将大于key的元素移到key的左侧，此时key就会被移动到整个数组排序完成之后的位置，然后对key左右两部分再次递归使用分支排序。

数组分为三部分，a、b、c代表每一部分的元素个数
[1,5,2,5]：第3大的数字是2

class Solution {
    public static void swap(int[] nums, int x, int y) {
        int temp = nums[x];
        nums[x] = nums[y];
        nums[y] = temp;
    }

    public int findKthLargest(int[] nums, int k) {
        return quickSort(nums, 0, nums.length - 1, k);
    }

    public static int quickSort(int[] nums, int l, int r, int k) {
        if (l == r)
            return nums[l];
        if(r - l + 1<=0){
            System.out.println("r:"+(r));
            System.out.println("l:"+(l));
            System.out.println("r-l+1:"+(r-l+1));
        }

        int key = nums[new Random().nextInt(r - l + 1) + l];
        int left = l - 1, right = r + 1, i = l;
        while (i < right) {
            if (nums[i] < key) {
                swap(nums, ++left, i++);
            } else if (nums[i] > key) {
                swap(nums, --right, i);
            } else {
                i++;
            }
        }
        if (r - right + 1 >= k)
            return quickSort(nums, right, r, k);
        else if (r - left >= k)
            return key;
        else
            return quickSort(nums, l, left, k - r + left);
        // int c = r - right + 1, b = right - left - 1;
        // if (c >= k)
        //     return quickSort(nums, right, r, k);
        // else if (c + b >= k)
        //     return key;
        // else
        //     return quickSort(nums, l, left, k - b - c);
    }

}

class Solution {
    public int findKthLargest(int[] nums, int k) {
        return qsort(nums, 0, nums.length - 1, k);
    }

    public int qsort(int[] nums, int l, int r, int k) {
        if (l == r) {
            return nums[l];
        }
        // 1. 按照随机选择的基准元素，将数组分三块
        int key = nums[new Random().nextInt(r - l + 1) + l];
        int left = l - 1, right = r + 1, i = l;
        while (i < right) {
            if (nums[i] < key)
                swap(nums, ++left, i++);
            else if (nums[i] == key)
                i++;
            else
                swap(nums, --right, i);
        }
        // 2. 分情况讨论
        int c = r - right + 1, b = right - left - 1;
        if (c >= k)
            return qsort(nums, right, r, k);
        else if (c + b >= k)
            return key;
        else
            return qsort(nums, l, left, k - b - c);
    }

    public void swap(int[] nums, int i, int j) {
        int t = nums[i];
        nums[i] = nums[j];
        nums[j] = t;
    }
}

指针数量太多，计算区间长度需谨慎，创建新变量记录小区间长度，大区间的长度就用小区间长度计算，避免使用下标计算出现错误

// 排序查询最小的k个数

// 堆

//快速选择排序
class Solution {
    public int[] inventoryManagement(int[] nums, int k) {
        qsort(nums, 0, nums.length - 1, k);
        int[] ret = new int[k];
        for (int i = 0; i < k; i++) {
            ret[i] = nums[i];
        }
        return ret;
    }
    public void qsort(int[] nums, int l, int r, int k) {
        if (l == r) {
            return ;
        }
        // 1. 按照随机选择的基准元素，将数组分三块
        int key = nums[new Random().nextInt(r - l + 1) + l];
        int left = l - 1, right = r + 1, i = l;
        while (i < right) {
            if (nums[i] < key)
                swap(nums, ++left, i++);
            else if (nums[i] == key)
                i++;
            else
                swap(nums, --right, i);
        }
        // 2. 分情况讨论
        int c = r - right + 1, b = right - left - 1, a = left - l + 1;
        if (a > k) {
            qsort(nums, l, left, k);
        } else if(a+b>=k) {
            return ;
        }else{
            qsort(nums, right, r, k - a - b);
        }
    }
    public static void swap(int[] nums, int i, int j) {
        int t = nums[i];
        nums[i] = nums[j];
        nums[j] = t;
    }
}

暴力解法时间复杂度为O(N^2)
数组逆序对数=左半部分逆序对数+右半部分逆序对数+一左一右逆序对数
如果将两部分数组进行排序，那么在合并的时候可以利用O(1)的时间统计一左一右逆序对数，这样一来统计所有逆序对是的时间复杂度就变成了对数组归并排序的时间复杂度，即O(N*logN)

class Solution {
    int[] temp;

    public int reversePairs(int[] record) {
        // 特殊情况 record为空
        int n = record.length;
        temp = new int[n];
        return mergeSort(record, 0, n - 1);
    }
    public int mergeSort(int[] arr, int left, int right) {
        if (left >= right) // 防止特殊情况 record数组为空
            return 0;
        int mid = left + (right - left) / 2;
        int a = mergeSort(arr, left, mid);
        int b = mergeSort(arr, mid + 1, right);
        int c = 0;
        int i = left, j = mid + 1, k = 0, n = right - left + 1;
        // [left,right]=[left,mid][mid+1,right]
        while (i <= mid && j <= right) {
            if (arr[i] > arr[j]) {
                temp[k++] = arr[i++];
                c += right - j + 1;
            } else {
                temp[k++] = arr[j++];
            }
        }
        while (i <= mid)
            temp[k++] = arr[i++];
        while (j <= right)
            temp[k++] = arr[j++];
        for (int x = 0; x < n; x++) {
            arr[left + x] = temp[x];
        }
        return a + b + c;
    }
}
// 8 6 4 2 1
// 5 3 1

找每一个位置的逆序对的数量，在第二题中我们利用归并排序统计了数组中逆序对的数量，这会导致数组元素位置移动，这就对统计每个位置逆序对的数量增加了难度。因为数组中元素并不是唯一的，所以无法使用哈希表去确定某个元素的下标。解决方案是创建一个数组存储每个元素的下标
nums：5、2、6、1
index：0、1、2、3
在归并排序时会改变nums中元素的顺序，知道将index的元素同步移动即可找到该元素的初始位置，有一个小细节，对nums合并排序的时候创建了辅助数组，index数组要同步移动，所以也要进行合并，那么就也需要创建一个辅助数组来完成index的合并。如何统计每个位置的逆序对数量呢？对于数组[left,right]=[left<=x<=mid]+[mid+1<=y<=right];

class Solution {
    int[] temp1;
    int[] temp2;
    int[] index;
    // 在归并排序过程中，数组元素会发生移动
    // 使用index同步移动来存储某元素原始下标即：
    // 对于任意下标i，index[i]是nums[i]的原始下标,i是nums[i]的当前下标
    public List<Integer> countSmaller(int[] nums) {
        // 辅助数组
        temp1 = new int[nums.length];
        temp2 = new int[nums.length];
        // index数组，标记nums数组元素原下标，并同步与nums进行排序
        index = new int[nums.length];
        // 对返回值进行初始化,也可将返回值创建成int[]，最后在进行转化。
        List<Integer> arr = new ArrayList<>();
        for (int i = 0; i < nums.length; i++){
            index[i] = i;
            arr.add(0);
        }
        mergeSort(nums, 0, nums.length - 1, arr);
        return arr;
    }
    public void mergeSort(int[] nums, int left, int right, List<Integer> arr) {
        if (left == right) return; // 细分到
        int mid = left + (right - left) / 2;
        mergeSort(nums, left, mid, arr);
        mergeSort(nums, mid + 1, right, arr);
        int i = left, j = mid + 1, k = 0;
        while (i <= mid && j <= right) {
            if (nums[i] > nums[j]) {
                arr.set(index[i],arr.get(index[i])+right-j+1);
                temp2[k] = index[i];
                temp1[k++] = nums[i++];
            } else {
                temp2[k] = index[j];
                temp1[k++] = nums[j++];
            }
        }
        while (i <= mid) {
            temp2[k] = index[i];
            temp1[k++] = nums[i++];
        }
        while (j <= right) {
            temp2[k] = index[j];
            temp1[k++] = nums[j++];
        }
        for (int x = 0; x < right - left + 1; x++) {
            nums[x + left] = temp1[x];
            index[x + left] = temp2[x];
        }
    }
}
// 6 4 2
// 5 3 1

class Solution {
    int[] temp;

    public int reversePairs(int[] nums) {
        temp = new int[nums.length];
        return megerSort(nums, 0, nums.length - 1);
    }

    public int megerSort(int[] nums, int left, int right) {
        if (left >= right) {
            return 0;
        }
        int ret = 0;
        int mid = left + (right - left) / 2;
        ret += megerSort(nums, left, mid);
        ret += megerSort(nums, mid + 1, right);

        // 统计重要反转对比较难在合并排序中实现，所以可以单独处理
        // [left,mid][mid+1,right] 两个降序的数组
        // 升序也可以
        int l = left, r = mid + 1;
        while (l <= mid && r <= right) {
            // 5 4
            // 3 2 1
            if ((long) nums[l] > (long) 2 * nums[r]) {
                ret += right - r + 1;
                l++;
            } else {
                r++;
            }
        }
        // 合并排序,降序
        int i = left, j = mid + 1, k = 0;
        while (i <= mid && j <= right) {
            if (nums[i] > nums[j]) {
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
            }
        }
        while (i <= mid)
            temp[k++] = nums[i++];
        while (j <= right)
            temp[k++] = nums[j++];
        for (int x = 0; x < right - left + 1; x++) {
            nums[left + x] = temp[x];
        }
        return ret;
    }
}