算法题目笔记

排序

快速排序

思路: 基准左边的值都小于基准值，右边都大于基准值。
two pointers双指针， 左右两个指针维护基准值位置(r==l)

/**
     * 思路: 记第一个元素是基准，剩余元素分为小于和大于两部分，然后把分界位置作为基准元素的位置
     * (给基准找到一个位置，使得该位置左边值均小于基准，右边值均大于基准)
     */
public static void  quickSort(int[] array, int begin, int end){
        if (begin >= end) return;
        // 第一个元素作为基准并记录
        int tmp = array[begin];
        // 左右两个指针
        int l = begin;
        int r = end;
        // l == r结束循环
        while (l < r){
            // 右指针所指元素小于等于基准值就把该元素放入左指针所在位置
            // 这样做到基准值右边都大于基准值
            while (l < r && array[r] > tmp) r--;
            array[l] = array[r];
            // 左指针所指元素大于等于基准值就把该元素放入右指针所在位置
            while (l < r && array[l] < tmp) l++;
            array[r] = array[l];
        }
        // l == r表示此时l左边都小于基准值， r右边都大于基准值
        // 因此把基准值放入该位置
        if (l == r) {
            array[l] = tmp;
        }
        // 递归快排基准左边和右边的序列
        quickSort(array, begin, l-1);
        quickSort(array, l+1, end);
    }

动态规划

适用于可以分解成多个相同子问题的最优解问题，且该问题的最优解可以由子问题的最优解构造出来。和递归的自顶向下相反，dp是自底向上，相当于经过剪枝操作的递归，节省重复的计算。

• 分治和dp都是将问题分解为子问题，合并子问题的解得到原问题的解。分治法的子问题不重叠， dp解决的问题拥有重叠子问题(比如Fibonacci数列计算f(6)=f(5)+f(4), f(5)=f(4)+f(3), f(4)有重复计算)。
• 贪心和dp都需要原问题必须有最优子结构。贪心通过策略选择一个子问题继续求解，其他子问题抛弃(单链的流水方式)。dp则从边界开始向上得到目标问题的解，会考虑所有子问题。

LCS最长公共子串

给出两个字符串x,y ，找出最长的公共子字符串: 子串的元素在物理位置上连续
思路: dp[i][j]存储 x.substring(0, i) 和 y.substring(0, j) 的以x[i] or y[j]结尾的公共子串的最长长度。即dp[][]记录了LCS的最后一个字符是x[i] or y[j]。
因此状态转移方程是x[i] == y[j], dp[i][j] = dp[i-1][j-1] + 1; else dp[i][j] = 0;
字符数组的第一个元素置空，有效字符从下标1开始，则dp[i][j]只要有一个下标是0值就为0(空字符和其他子串都没有公共子串)。

该算法的时间复杂度和空间复杂度均为O(n^2)

public static int solve2(char[] x, char[] y){
        int maxLCS = 0;
        int dp[][] = new int[x.length][y.length];
        // x, y 的第一个字符为空, 有效字符从下标1开始， 避免i-1 or j-1下标溢出
        for (int i = 1; i < x.length; i++) {
            for (int j = 1; j < y.length; j++) {
                // x和y的当前元素相同，才可能有以该元素结尾的公共子串
                if (x[i] == y[j]) {
                    // 当前两个子串的公共子串取决于x和y的前一个元素是否也相同
                    dp[i][j] = dp[i-1][j-1] + 1;
                    maxLCS = Math.max(maxLCS, dp[i][j]);
                }
            }
        }
        return maxLCS;
    }

优化: 根据状态转移方程可知计算dp[][]只取决于前一行的数据，因此使用滚动数组dp[0]和dp[1]轮流存当前和前一行数据。时间复杂度O(n^2), 空间复杂度O(2*n)

public static int solve3(char[] x, char[] y){
        int maxLCS=0;
        int dp[][] = new int[2][y.length]; 
        for (int i = 1; i < x.length; i++) {
            for (int j = 1; j < y.length; j++) {
                // i从1开始，初始cur=1,pre=0
                // i奇数 cur=1,pre=0
                // 滚动数组, dp[1]和dp[0]轮流充当cur, 则另一个dp[]为pre
                int cur = (i&1)==1 ? 1 : 0;
                int pre = (i&1)==0 ? 1 : 0;
                if (x[i] == y[j]) {
                    dp[cur][j] = dp[pre][j-1] + 1;
                    maxLCS = Math.max(maxLCS, dp[cur][j]);
                } else dp[cur][j] = 0;
            }
        }
        return maxLCS;
    }