蓝桥杯, 你还不会这些算法?

最新推荐文章于 2021-12-19 08:00:00 发布
最新推荐文章于 2021-12-19 08:00:00 发布
阅读量659 收藏 15
点赞数 4
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/idefined/article/details/104870469
版权

1.输入

推荐使用这种的输入，读取的数据量大的时候，速度更快。

static class InputReader {
        private BufferedReader bf = null;
        private StringTokenizer stz = null;
        public InputReader() {
            bf = new BufferedReader(new InputStreamReader(System.in),32*1024);
        }
        public boolean hasNext() {
            while(stz == null || !stz.hasMoreTokens()) {
                try {
                    stz = new StringTokenizer(bf.readLine());
                } catch (IOException e) {
                    return false;
                }
            }
            return true;
        }
        public String next() {
            if(hasNext()) {
                return stz.nextToken();
            }
            return null;
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }

2.进制转换

十进制转换成n进制

InputReader sc  = new InputReader();
int num = sc.nextInt();
System.out.println(Integer.toString(num, 16));//这里是转成16进制

n进制转换成十进制

InputReader sc  = new InputReader();
String str = sc.next();
System.out.println(Integer.valueOf(str, 16));//这里代表字符串使用16进制表示的

以上处理的进制问题没有考虑溢出问题。也就是某个进制代表的数字很大，int类型不足以表示

n进制转换十进制（推荐）

InputReader sc  = new InputReader();
String str = sc.next();
BigInteger bigInteger = new BigInteger(str, 16);
System.out.println(bigInteger);

3. 日期运算（Calendar的API使用）

真题：世纪末的星期
1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年（即xx99年）的12月31日正好是星期天（即星期日）？
请回答该年份（只写这个4位整数，不要写12月31等多余信息）。

public static void main(String[] args) {
    Calendar calendar = Calendar.getInstance();
    for (int i = 1999; i < 10000; i+=100) {
        calendar.set(i, 11, 31);//月份从0开始计算
        if(calendar.get(Calendar.DAY_OF_WEEK) == 1) {
            System.out.println(i);  //2299
            break;
        }
    }
}

（补充）滑动窗口

待更新

4.递归

递归就是思考解决问题的方向是自顶向下的

4.1. 最常用的递归就是全排列

不带重复排列的全排列

public class Main {
    static int[] arr = {1,1,3,3};
    static boolean[] vis = new boolean[arr.length];
    static int[] res = new int[arr.length];
    static HashSet<String> hashSet = new HashSet<String>(); 
    public static void main(String[] args) {
        f(0);
    }
    private static void f(int cur) {
        String str = "";
        if(cur == arr.length) {
            for(int i=0;i<arr.length;i++) {
                str += arr[i];
            }
            if(!hashSet.contains(str)) {
                hashSet.add(str);
                System.out.println(str);
            }
            return;
        }
        for (int i = cur; i < arr.length; i++) {
            swap(i,cur);
            f(cur+1);
            swap(i,cur);
        }
    }
    private static void swap(int a,int b) {
        int t = arr[a];
        arr[a] = arr[b];
        arr[b] = t;
    }
}
4.2. 递归转递推
4.3. DFS(搜索+检查)

标题: 振兴中华
小明参加了学校的趣味运动会，其中的一个项目是：跳格子。
地上画着一些格子，每个格子里写一个字，如下所示

从我做起振
我做起振兴
做起振兴中
起振兴中华

比赛时，先站在左上角的写着“从”字的格子里，可以横向或纵向跳到相邻的格子里，但不能跳到对角的格子或其它位置。一直要跳到“华”字结束。
要求跳过的路线刚好构成“从我做起振兴中华”这句话。
请你帮助小明算一算他一共有多少种可能的跳跃路线呢？

思路：将“从我做起振兴中华”用数字0到7代替从0开始往下和往右深搜

static int[][] arr = { 
            { 0, 1, 2, 3, 4 }, 
            { 1, 2, 3, 4, 5 }, 
            { 2, 3, 4, 5, 6 }, 
            { 3, 4, 5, 6, 7 } 
        };
    static boolean[][] visited = new boolean[4][5];
    public static void main(String[] args) {
        int ans = dfs(0,0,0);
        System.out.println(ans); //35
    }
    /**
     * 
     * @param x
     * @param y  x ,y 是坐标
     * @param cur 当前应该是第几个数字
     */
    private static int dfs(int x, int y,int cur) {    
        int res = 0;
        visited[x][y] = true;
        if(cur == 7 && arr[x][y] == 7) {
            return 1;
        }
        if(inArea(x+1,y) && !visited[x+1][y]) {
            res+=dfs(x+1,y,cur+1);
            visited[x+1][y] = false;//回溯
        }
        if(inArea(x,y+1)&& !visited[x][y+1]) {
            res+=dfs(x,y+1,cur+1);
            visited[x][y+1] = false;//回溯
        }
        return res;
        
    }
    private static boolean inArea(int x, int y) {
        if(x>=0 && x < 4 && y>=0 && y < 5) {
            return true;
        }
        return false;
    }

当然这是最一般的解法，但是题目给的数据比较特殊，从左上到右下每一个位置，都可以往下或者右走，并且一定只能是这个顺序。于是可以这样写

public static void main(String[] args) {
        int ans = f(0,0);
        System.out.println(ans); //35
    }

    private static int f(int x, int y) {
        int res = 0;
        if(x==3 && y== 4) {
            return 1;
        }
        if(x+1>=0 && x+1<=3)
            res+= f(x+1,y);
        if(y+1>=0 && y+1<=4)
            res+= f(x, y+1);
        return res;
    }
4.3 记忆型递归与博弈型问题

待更新。。。

5.枚举，全排列暴力解法

标题1：六角填数

如图【1.png】所示六角形中，填入1~12的数字。
使得每条直线上的数字之和都相同。
图中，已经替你填好了3个数字，请你计算星号位置所代表的数字是多少？
在这里插入图片描述
思路: 按照从上到下，从左到右对还没有填入的数字进行编号，题目转换为求下标为3的那个数是多少

public static void main(String[] args) {
        int[] arr = {2,4,5,6,7,9,10,11,12};
        f(arr,0);//全排列
    }

    private static void f(int[] arr,int cur) {
        if(cur == arr.length) {
            check(arr);
            return;
        }
        for(int i=cur;i<arr.length;i++) {
            swap(arr,i,cur);
            f(arr,cur+1);
            swap(arr,i,cur);
        }
        
    }

    private static void check(int[] arr) {
        int r1 = 1 + arr[0]+arr[3]+arr[5];
        int r2 = 1 + arr[1]+arr[4]+arr[8];
        int r3 = 8 + arr[0]+arr[1]+arr[2];
        int r4 = 11 + arr[6]+arr[3];
        int r5 = 3 + arr[2]+arr[4]+arr[7];
        int r6 = arr[5] + arr[6]+arr[7]+arr[8];
        if(r1==r2&&r2==r3&&r3==r4&&r4==r5&&r5==r6) {
            for(int i=0;i<arr.length;i++) {
                System.out.print(arr[i]+" "); //9 2 7 10 12 6 5 4 11  所以答案为10
            }
        }
    }

    private static void swap(int[] arr, int i, int cur) {
        int t = arr[i];
        arr[i] = arr[cur];
        arr[cur] = t;
    }

再举个例子

生日蜡烛

某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。
现在算起来，他一共吹熄了236根蜡烛。
请问，他从多少岁开始过生日party的？
请填写他开始过生日party的年龄数。

static int sum(int start, int end) {
        return (start+end) * (end - start +1) /2;//等差数列求和公式
    }

    public static void main(String[] args) {
        for (int start = 1; start < 100; start++) {
            for (int end = start + 1; end < 100; end++) {
                if(sum(start,end) == 236) {
                    System.out.println(start +" " +end);//26   33 所以答案就是26
                }
            }
        }
    }

6.快速幂运算

public static int quickExp(int n,int m) {
        int res = 1;
        while(m > 0) {
            if((m&1)==1) {
                res *= n;
            }
            n =  n*n;
            m = m>>1;
        }
        return res;
    }

7.矩阵运算

矩阵乘法运算

private static int[][] multiple(int[][] m1, int[][] m2) {
        int[][] res = new int[m1.length][m2[0].length];
        for(int i=0;i<m1.length;i++) {
            for(int j=0;j<m2[i].length;j++) {
                for(int k=0;k<m2.length;k++) {
                    res[i][j] += m1[i][k]* m2[k][j];
                }
            }
        }
        return res;
    }

矩阵快速幂运算

private static int[][] quickExp(int[][] m, int n) {
        int[][] res = new int[N][N];
        for(int i=0;i<N;i++) {
            for (int j = 0; j < N; j++) {
                if(i == j) res[i][j] = 1;
                else res[i][j] = 0;
            }
        }
        while(n>0) {
            if((n & 1) == 1)
                res = multiple(res, m); //调用的是上面的矩阵乘法公式
            m = multiple(m, m);
            n = n>>1;
        }
        return res;
    }

应用：快速求斐波那契数O(logn)的时间复杂度。（在最后会提到）

8.贪心

9.动态规划(dp)(*****)

前面讲过递归就是思考解决问题的方向是自顶向下的，而动态规划是恰恰相反。
在这里插入图片描述

不过，通常在解决问题的时候，我们应该先要自顶向下的思考，因为自顶向下思考问题，比较简单。

[引用自leetcode上的一个例子] 如果一个问题是动态规划问题，它应该具有 「最优子结构」 的。要符合 「最优子结构」 ，子问题间必须互相独立。啥叫相互独立？你肯定不想看数学证明，我用一个直观的例子来讲解。比如说，你的原问题是考出最高的总成绩，那么你的子问题就是要把语文考到最高，数学考到最高…… 为了每门课考到最高，你要把每门课相应的选择题分数拿到最高，填空题分数拿到最高…… 当然，最终就是你每门课都是满分，这就是最高的总成绩。

得到了正确的结果：最高的总成绩就是总分。因为这个过程符合最优子结构，“每门科目考到最高”这些子问题是互相独立，互不干扰的。

但是，如果加一个条件：你的语文成绩和数学成绩会互相制约，此消彼长。这样的话，显然你能考到的最高总成绩就达不到总分了，按刚才那个思路就会得到错误的结果。因为子问题并不独立，语文数学成绩无法同时最优，所以最优子结构被破坏。

从最简单的dp开始

例1：leetcode 70 爬楼梯

与斐波那契数列类似

class Solution {
    private int[] memo;

    public int climbStairs(int n) {
        if (n == 1) return 1;
        if (n == 2) return 2;
        memo = new int[n + 1];
        memo[1] = 1;
        memo[2] = 2;
        for (int i = 3; i < n + 1; i++) {
            memo[i] = memo[i - 1] + memo[i - 2];
        }
        return memo[n];
    }
}

如果感觉没问题的话，可以练习下面两道题：

 leetcode120 Triangle

 leetcode 64 Minimum Path Sum

例2：整数拆分

2.1 简单递归解法
分析：在这里插入图片描述

class Solution {
    public int integerBreak(int n) {
        return breakInteger(n);
    }

    //计算n的拆分乘积最大值，注意：一定会将n至少分成两部分
    private int breakInteger(int n) {
        if (n == 1)
            return 1;
        int res = 0;
        for (int i = 1; i < n; i++) {
            res = max3(res,i * (n-i),i * breakInteger(n - i));
        }
        return res;
    }

    private int max3(int a, int b, int c) {
        return Math.max(Math.max(a, b), c);
    }

    // public static void main(String[] args) {
    //    System.out.println(new Solution().integerBreak(4));
    //}
}

得到结果：
在这里插入图片描述

2.2 记忆型递归

记忆型递归的技巧，在每个求出结果的地方记录，在递归之前查询。

class Solution {
    private int[] memo; //memeo[i]代表第i个的拆分最大乘积
    public int integerBreak(int n) {
        memo = new int[n+1];
        return breakInteger(n);
    }

    //计算n的拆分乘积最大值，注意：一定会将n至少分成两部分
    private int breakInteger(int n) {
        if (n == 1)
            return 1;
        if(memo[n]!=0)
            return memo[n];
        int res = 0;
        for (int i = 1; i < n; i++) {
            res = max3(res,i * (n-i),i * breakInteger(n - i));
        }
        memo[n] = res;
        return res;
    }

    private int max3(int a, int b, int c) {
        return Math.max(Math.max(a, b), c);
    }

    //public static void main(String[] args) {
   //     System.out.println(new Solution().integerBreak(10));
   // }
}

2.3 动态规划（自底向上）

class Solution {
    public int integerBreak(int n) {
        int[] dp = new int[n + 1];
        dp[1] = 1;
        for (int i = 2; i < n + 1; i++) {
            for (int j = 1; j <= i-1; j++) {
                dp[i] = max3(dp[i], j * (i - j), j * dp[i-j]);
            }
        }
        return dp[n];
    }

    private int max3(int a, int b, int c) {
        return Math.max(Math.max(a, b), c);
    }

    public static void main(String[] args) {
        System.out.println(new Solution().integerBreak(5));
    }
}

leetcode练习：

   279. 完全平方数

   91. 解码方法

   62. 不同路径

   63. 不同路径 II

例3：打家劫舍

3.1 递归写法（自下而上）

状态的定义：考虑偷取[ x … n-1]范围的房子 。通常把对状态的定义也叫做函数的定义

class Solution {
    public int rob(int[] nums) {
        return tryRob(nums, 0);
    }

    private int tryRob(int[] nums, int start) {//start代表从哪个位置开始
        if(start >= nums.length){
            return 0;
        }
        int res = 0;
        
        // res = Math.max(tryRob(nums, start + 1), nums[i] + tryRob(nums, i + 2));
        // 这也是一种递归写法。
        for (int i = start; i < nums.length; i++) {
            res = Math.max(res, nums[i] + tryRob(nums, i + 2));
        }
        return res;
    }

}

3.2 记忆型递归

class Solution {
    private int[] memo;
    public int rob(int[] nums) {
        memo = new int[nums.length];
        return tryRob(nums, 0);
    }

    private int tryRob(int[] nums, int start) {//start代表从哪个位置开始
        if(start >= nums.length){
            return 0;
        }
        //开始前查询
        if(memo[start]!=0)
            return memo[start];
        int res = 0;
        for (int i = start; i < nums.length; i++) {
            res = Math.max(res, nums[i] + tryRob(nums, i + 2));
        }
        //返回结果前记录 
        memo[start] = res;
        return res;
    }
}

3.3 动态规划（自顶向下）

class Solution {
    private int[] dp;//dp[index] 代表从index的位置开始到最后一间房抢到的价值最大值
    private int n;

    public int rob(int[] nums) {
        this.n = nums.length;
        if(nums.length == 0) return 0;
        dp = new int[n];
        dp[n - 1] = nums[n - 1];//只有一个房间，那就抢。不用考虑------最基本问题
        //考虑从i开始抢到的价值最大值
        for (int i = n - 2; i >= 0; i--) {

            for (int j = i; j < n; j++)
                dp[i] = Math.max(dp[i],  ((j + 2) < n ? dp[j + 2] : 0 ) + nums[j]);//一定要用已知的结果
        }
        return dp[0];
    }

}

思考： 如果状态这样定义：考虑偷取[ 0 … x ]范围里的房子 。

3.1 递归写法

class Solution {

    public int rob(int[] nums) {
        if (nums.length == 0) return 0;
        return tryRob02(nums, nums.length - 1);
    }

    private int tryRob02(int[] nums, int end) {
        if (end < 0) {
            return 0;
        }
        int res = 0;
        for (int i = end; i >= 0; i--) {//这里对[end....0]的每一个尝试偷取
            res = Math.max(res, nums[i] + tryRob02(nums, i - 2));//从[end...0]这多个分支中取得最大值
        }
        return res;
    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        int[] nums = {2,7,9,3,1};
        System.out.println(new Solution().rob(nums));
        long end = System.currentTimeMillis();
        System.out.println(end - start + "ms");
    }
}

3.2 记忆型递归

class Solution {
    private int[] memo;

    public int rob(int[] nums) {
        if (nums.length == 0) return 0;
        memo = new int[nums.length];
        return tryRob02(nums, nums.length - 1);
    }

    private int tryRob02(int[] nums, int end) {
        if (end < 0) {
            return 0;
        }
        //递归前查询
        if (memo[end] != 0)
            return memo[end];
        int res = 0;
        for (int i = end; i >= 0; i--) {//这里对[end....0]的每一个尝试偷取
            res = Math.max(res, nums[i] + tryRob02(nums, i - 2));//从[end...0]这多个分支中取得最大值
        }
        //返回结果前记录
        memo[end] = res;
        return res;
    }
}

3.3 动态规划

class Solution {
    private int[] dp;//dp[index] 表示从0~index范围偷取的最大值
    private int n;

    public int rob(int[] nums) {
        if (nums.length == 0) return 0;
        this.n = nums.length;
        dp = new int[n];
        //找到最基本的问题的解
        dp[0] = nums[0];
        //由已知解逐步递推
        for (int i = 1; i < n; i++) {
            for (int j = i; j >= 0; j--) {
                dp[i] = Math.max(dp[i], nums[j] + (j - 2 >= 0 ? dp[j - 2] : 0));
            }
        }
        return dp[n-1];
    }
    
}

4. 01背包问题

4.1递归解法

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

/**
 * 01背包的状态方程 F(n,c) n代表前n个物品，c代表背包容量
 * F(i,c) = max(  F(i-1,c) , v[i] + F(i,c-v[i])  )
 */
public class Main {
    /**
     * @param w 重量
     * @param v 价值
     * @param c 背包容量
     * @return
     */
    public static int knapsack01(int[] w, int[] v, int c) {
        return bestValue(w, v, 0, c);
    }

    private static int bestValue(int[] w, int[] v, int index, int c) {
        if (index >= w.length || c <= 0)
            return 0;
        int res = bestValue(w, v, index + 1, c);
        if (c > w[index])
            res = Math.max(res, v[index] + bestValue(w, v, index + 1, c - w[index]));
        return res;
    }

    public static void main(String[] args) {
        InputReader sc = new InputReader();
        int n = sc.nextInt();
        int c = sc.nextInt();
        int[] v = new int[n];
        int[] w = new int[n];
        for (int i = 0; i < n; i++) {
            w[i] = sc.nextInt();
            v[i] = sc.nextInt();
        }
        System.out.println(knapsack01(w, v, c));
    }
    /*
     * 下面就是输入类，之前介绍过了。可以不用在意
     */
    static class InputReader {
        private BufferedReader bf;
        private StringTokenizer stz;

        public InputReader() {
            bf = new BufferedReader(new InputStreamReader(System.in), 32 * 1014);
            stz = null;
        }

        public boolean hasNext() {
            while (stz == null || !stz.hasMoreTokens()) {
                try {
                    stz = new StringTokenizer(bf.readLine());
                } catch (IOException e) {
                    return false;
                }
            }
            return true;
        }

        public String next() {
            if (hasNext())
                return stz.nextToken();
            return null;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
    }
}

4.2 记忆型递归（核心代码）

注意memo的开辟空间

private int bestValue(int[] w, int[] v, int index, int c) {
        if (index > w.length || c <= 0)
            return 0;
        //递归前查询
        if(memo[index][c] != 0)
            return memo[index][c];
        int res = bestValue(w, v, index + 1, c);
        if (c > w[index])
            res = Math.max(res, v[index] + bestValue(w, v, index + 1, c - w[index]));
        //返回前记录
        memo[index][c] = res;

        return res;
    }

4.3 动态规划（核心）

private int[][] dp; //dp[index][c]代表 背包容量剩余c和可选[0,index]物品的价值最大值
    private int n;

    /**
     * @param w 重量
     * @param v 价值
     * @param c 背包容量
     * @return
     */
    public int knapsack01(int[] w, int[] v, int c) {
        dp = new int[w.length][c + 1];
        n = w.length;
        return bestValue(w, v, 0, c);
    }

    private int bestValue(int[] w, int[] v, int index, int c) {
        if (c <= 0 || w.length == 0)
            return 0;
        //初始化基本问题-------只有0 ~ 0（只有0）之间的物品可选
        for (int capacity = 0; capacity <= c; capacity++) {
            if (capacity >= w[0])
                dp[0][capacity] = v[0];
            else
                dp[0][capacity] = 0;
        }

        //有基本问题推出一般问题
        for (int i = 1; i < n; i++) {
            for (int cap = 0; cap <= c; cap++) {
                if(cap >= w[i])
                    dp[i][cap] = Math.max(dp[i-1][cap],v[i] + dp[i-1][cap - w[i]]);
                else
                    dp[i][cap] = dp[i-1][cap];
            }
        }
        return dp[n-1][c];
    }

例5：leetcode 416 基于01背包的问题

详细见代码注释

class Solution {
    /**
     * 状态定义：F(i,C) i代表0~i的可选范围，C代表填充的背包容量（在这里背包的容量就是sum/2）
     * 方程的含义是：在0~i的范围里能否填充C
     * 状态转移方程F(i,C) --> F(i-1,C) || F(i,C-nums[i])
     */
    public boolean canPartition(int[] nums) {
        if (nums.length < 0)
            return false;
        int n = nums.length;
        int C = 0;
        for (int i = 0; i < n; i++)
            C += nums[i];
        if (C % 2 != 0)
            return false;
        C = C / 2;
        boolean[] dp = new boolean[C + 1];
        //找到基本问题的解
        for (int i = 0; i <= C; i++) {
            dp[i] = (nums[0] == i);//只用第1（从0到0  [0]）个数字去试试能不能填满背包
        }
        //试试用[0...i]的范围，一步一步推导
        for (int i = 1; i < n; i++) {
            for (int j = C; j >= nums[i]; j--) {
                dp[j] = dp[j] || dp[j - nums[i]];
            }
        }
        return dp[C];
    }
}

练习：兑换硬币

       组合总和

一和零

       单词差分

  　   目标和

例6：最长上升子序列(LIS)

分析在代码中已体现

class Solution {
    /**
     * 状态的定义：LIS(i) 一定以i结尾的最长递增子序列
     * 状态的转移：LIS(i) --> 1 + LIS(j | if(nums[j] < nums[i]) )
     */
    private int n;
    public int lengthOfLIS(int[] nums) {
        this.n = nums.length;
        if(nums.length == 0) return 0;
        int[] dp = new int[n];
        //找到基本问题的解
        for (int i = 0; i < n; i++)
            dp[i] = 1;
        //根据状态转移方程推导更进一步问题的解
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if(nums[j] < nums[i] && dp[i] < 1 + dp[j] ){
                    dp[i] = 1 + dp[j];
                }
            }
        }
        //一定要注意返回的是dp数组中的最大值 不是直接return dp[n].
        int res = 0;
        for (int i = 0; i < n; i++) {
            res = Math.max(res,dp[i]);
        }
        return res;
    }

    public static void main(String[] args) {
        System.out.println(new Solution().lengthOfLIS(new int[]{1,3,6,7,9,4,10,5,6}));
    }
}

如果进一步求出这个子序列是什么呢？

练习：leetcode 摆动序列

更多的问题：

最长公共子序列（LCS）

状态的定义： LCS(m , n) 代表 s1[0…m] 和 s2[0…n]的最长公共子序列的长度

状态转移方程：
分为两种情况：

如果s1[m] == s2[n]

   LCS(m,n) =  1 + LCS ( m-1 , n-1)

如果s1[m] ！= s2[n]

　　LCS(m , n ) = max(LCS(m-1,n) ,  LCS( m , n-1 ) ) 

class Solution {
    /**
     * 状态定义： LCS(m , n)  代表 s1[0....m] 和  s2[0.....n]的最长公共子序列的长度
     * 状态转移方程：
     * 如果s1[m] == s2[n]
     * LCS(m,n) =  1 + LCS ( m-1 , n-1)
     * 如果s1[m] ！= s2[n]
     * 　　LCS(m , n ) = max(LCS(m-1,n) ,  LCS( m , n-1 ) )
     */
    private String s1;
    private String s2;

    public int longestCommonSubsequence(String text1, String text2) {
        this.s1 = text1;
        this.s2 = text2;
        return LCS(s1.length() - 1, s2.length() - 1);
    }

    private int LCS(int m, int n) {
        //找到一般问题的解
        int[][] dp = new int[n + 1][m + 1];//dp[i][j]的含义是：s1[0..i]与s2[0..j]的最长公共子序列
        boolean flag = false;
        for (int i = 0; i <= m; i++)
            if (!flag && s2.charAt(0) == s1.charAt(i)) {
                dp[0][i] = 1;
                flag = true;
            }else if(flag){
                dp[0][i] = 1;
            }
        //根据状态转移方程推出更进一步的问题的解
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                if (s2.charAt(i) == s1.charAt(j))
                    if( i-1 >=0 && j-1>=0)
                        dp[i][j] = 1 + dp[i - 1][j - 1]; //这里与递归是一样的意义
                    else
                        dp[i][j] = 1;
                else
                    dp[i][j] = Math.max((i-1>=0?dp[i - 1][j]:0), (j-1>=0?dp[i][j - 1]:0));//这里与递归是一样的意义
            }
        }
        return dp[n][m];
    }

    public static void main(String[] args) {
        System.out.println(new Solution().longestCommonSubsequence("bl", "yby"));
    }
}

9.树

线段树/区间数

/**
 * 该接口是为了为了使线段树更通用。
 * 当要求一段区间的和 ，merge的功能是 求 a+b
 * 当要求一段区间的积 ，merge的功能是 求 a*b
 * 也就是对于不同的业务，不需要重新修改SegmentTree的代码
* @author zhanyuhao
* @version 创建时间：2020年3月3日 下午9:57:45
* 类说明
 */
public interface Merger<E> {
    E merge(E a,E b);
}

/**
 * 线段树（区间树）
 * 
 * @author zhanyuhao
 * @version 创建时间：2020年3月3日 下午7:55:54 类说明
 */
public class SegmentTree<E> {
    private E[] data;
    private E[] tree;
    private Merger<E> merger;

    public SegmentTree(E[] arr, Merger<E> merger) {
        this.merger = merger;
        data = (E[]) new Object[arr.length];
        tree = (E[]) new Object[4 * arr.length];
        for (int i = 0; i < arr.length; i++)
            data[i] = arr[i];
        buildTree(0, 0, data.length - 1);
    }

    private void buildTree(int treeIndex, int l, int r) {
        if (l == r) {
            tree[treeIndex] = data[l];
            return;
        }
        int mid = l + (r - l) / 2;
        int leftIndex = leftChild(treeIndex);
        int rightIndex = rightChild(treeIndex);

        buildTree(leftIndex, l, mid);
        buildTree(rightIndex, mid + 1, r);

        tree[treeIndex] = merger.merge(tree[leftIndex], tree[rightIndex]);
    }

    public E query(int queryL, int queryR) {
        if (queryL < 0 || queryL >= data.length || queryR < 0 || queryR >= data.length) {
            throw new IllegalArgumentException("not exist");
        }
        return queryHelp(0, 0, data.length - 1, queryL, queryR);
    }

    private E queryHelp(int treeIndex, int l, int r, int queryL, int queryR) {
        if (queryL == l && queryR == r) {
            return tree[treeIndex];
        }
        int mid = l + (r - l) / 2;
        int leftIndex = leftChild(treeIndex);
        int rightIndex = rightChild(treeIndex);
        if (queryR <= mid) {// 结果在左子树
            return queryHelp(leftIndex, l, mid, queryL, queryR);
        } else if (queryL > mid) {
            return queryHelp(rightIndex, mid + 1, r, queryL, queryR);
        }
        // 结果分布在两边
        E leftResult = queryHelp(leftIndex, l, mid, queryL, mid);
        E rightResult = queryHelp(rightIndex, mid + 1, r, mid + 1, queryR);
        return merger.merge(leftResult, rightResult);
    }

    public void set(int index, E val) {
        if (index < 0 || index >= data.length) {
            new IllegalArgumentException("error");
        }
        set(0, 0, data.length-1, index, val);
    }

    private void set(int treeIndex, int l, int r, int index, E val) {
        if (r == l) {
            tree[treeIndex] = val;
            return;
        }
        int mid = l + (r - l) / 2;
        int leftIndex = leftChild(treeIndex);
        int rightIndex = rightChild(treeIndex);
        if(index <= mid) {
            set(leftIndex,l,mid,index,val);
        }else 
            set(rightIndex,mid+1,r,index,val);
        //因为改变了叶子节点的内容，所以一定要更新其父节点的内容，这是一个联动的效果
        tree[treeIndex] = merger.merge(tree[leftIndex], tree[rightIndex]);
    }

    private int leftChild(int index) {
        return 2 * index + 1;
    }

    private int rightChild(int index) {
        return 2 * index + 2;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < tree.length; i++) {
            if (tree[i] != null)
                sb.append(tree[i] + " ");
            else {
                sb.append("null ");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

下面是测试代码

public class Main {

    public static void main(String[] args) {
        Integer[] arr = { -2, 0, 3, -5, 2, -1, 1, 3 };
        SegmentTree<Integer> seg = new SegmentTree<Integer>(arr,(a,b)->a+b);//这里使用的是lamda表达式
        seg.set(1, 1);
        seg.set(0, 1);
        seg.set(3, 4);
        System.out.println(seg.query(0, 4));//求出了数组下标为0 - 4 的和
    }
}

10.dfs

待更新

11.bfs

待更新

12.必备的技巧

12.1 状态压缩

定义：简单来说就是某种状态需要由多个变量/元素确定，但是我们用一种方法将状态 压缩成一个或者更少的变量/元素就可以表示这个状态

如：二维数组用一个变量来表示。

数组大小为row*col  

则：v = x * row + col //用一个v来存储这种状态

 i = v / col //转换回去 

 j = v % col
12.2 取模的技巧（用于处理非常大的数据）
(a * b)  % c  =  ((a % c) * (b % c) ) % c

(a + b)  % c  =  ((a % c) + (b % c) ) % c
12.3 钟表类型的计算
比如一个数字只在0-12，当12 再加 1 就变成 0

那么 num = num % 12 ;

利用这个将减法变成加法 还是上面的例子，一个数减1 就等于这个数加 12

比如：0 - 1 = 12

转换成 0 + 12 = 12

也就是 (num-1) % 12 = (num+12)%12

这里只是举了一个特例 取余的那个数为 12 。具体遇到特殊情况，特殊对待
12.4 字符转数字互转换
将字符减去 '0' 的到的就是数字　　

Character.forDigit(int digit, int radix)；//将数字转换成字符
12.5“四 / 八联通”

通常用于dfs的搜索

//四联通：
//设置一个二维数组为dirs[4][2] = [ [-1,0] , [0,1] , [1,0], [-1,0] ] //分别代表上，右，下，左

for (int d = 0; d < 4; d++) {
     nextx = x + dirs[d][0];
     nexty = y + dirs[d][1];
}
//八连通：

for (int i = -1; i < 2; i++) {//-1 0 1
     for (int j = -1; j < 2; j++) { // -1 0 1
         if(i==0 && j==0) //排除自身，剩下的就是8个方向
             continue;
         //.....
     }
 }
12.6斐波那契数列

前面提到了可以利用矩阵来快速计算斐波那契数列的第n项
在这里直接给出公式，感兴趣原理的，可以自己去查寻相关资料。
在这里插入图片描述

static int[][] m= {
            {1,1},
            {1,0}
    };
    static int N = m.length;
    /**
     * 通常快速求斐波那契数列需要结合BigInteger来使用，或者需要取余。这里没有考虑。
     */
    public static void main(String[] args) {
        for(int i=1;i<40;i++) {//从第3项开始的前n项和
            int[][] res = quickExp(m,i);
            int[][] init = {{1,1},{0,0}};
            
            init = multiple(init, res);
            System.out.println(init[0][0]);
        }
    }

    private static int[][] quickExp(int[][] m, int n) {
        int[][] res = new int[N][N];
        for(int i=0;i<N;i++) {
            for (int j = 0; j < N; j++) {
                if(i == j) res[i][j] = 1; 
                else res[i][j] = 0;
            }
        }
        while(n>0) {
            if((n & 1) == 1)
                res = multiple(res, m);
            m = multiple(m, m);
            n = n>>1;
        }
        return res;
    }

    private static int[][] multiple(int[][] m1, int[][] m2) {
        int[][] res = new int[m1.length][m2[0].length];
        for(int i=0;i<m1.length;i++) {
            for(int j=0;j<m2[i].length;j++) {
                for(int k=0;k<m2.length;k++) {
                    res[i][j] += m1[i][k]* m2[k][j];
                }
            }
        }
        return res;
    }

更多更全的代码及内容：https://github.com/zhanyha/lanqiao

博客园：https://www.cnblogs.com/HoweZhan

做最好
关注
专栏目录
第十四届蓝桥杯北京赛区如何查成绩？ 第十四届蓝桥杯北京赛区获奖名单
04-23
蓝桥杯的C/C++程序设计比赛，不仅考察参赛者的编程能力，还评估他们对数据结构、算法分析、问题解决策略的掌握程度。获得一等奖的选手将有机会进入决赛，进一步展示自己的实力，并可能获得更多的学术和职业发展机会...
蓝桥杯python基础知识和算法
01-22
"蓝桥杯Python基础知识和算法"是一个针对编程竞赛...通过学习和实践这些内容，参赛者可以提升自己的Python编程能力和算法思维，更好地应对蓝桥杯竞赛。同时，也可以为日常的编程项目和未来的职业发展打下坚实的基础。
蓝桥杯比赛算法总结
小学生辉辉辉的博客
11-12 5312
title: 蓝桥杯比赛算法总结 date: 2015-06-18 22:35:24 categories: programming tags: [算法] 今天突然想把我自己在蓝桥杯比赛时准备的一些算法记录下来，以便翻阅。 [图片] 蓝桥杯官网
第五届蓝桥杯省赛不会的题们~
qiulianshaonv_wjm的博客
03-14 352
如果x的x次幂结果为10（参见【图1.png】），你能计算出x的近似值吗？ 显然，这个值是介于2和3之间的一个数字。 请把x的值计算到小数后6位（四舍五入），并填写这个小数值。 注意：只填写一个小数，不要写任何多余的符号或说明。 解析：这个题 我用计算器算的，大概算了七八分钟的样子。 然后看程序感觉挺简单的，用了个二分，当时怎么没想到呢。 #include &lt;stdio.h&g...
第十一届蓝桥杯第二次模拟（好多不会）
和BUG做朋友的zhi的博客
04-18 509
目录A 12.5MBB 最多边数C 单词重排D 括号序列（不会）E 反倍数（优化不会）F 凯撒加密G 螺旋（找规律）H 摆动序列I 通电J 植树 A 12.5MB 【问题描述】在计算机存储中，12.5MB是多少字节？【答案提交】这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。 【Answer】 12.5 × 1024 × 1024 = 13107200 B 最多边数 【问题描述】一个包含有2019个结点的有向图，最多包含多少条边
蓝桥杯之技术总结1
qq_43203129的博客
01-21 211
一、.输入一个int类型数字，输入对应的小数点位数 1.DecimalFormat df = new DecimalFormat("#.00"); 其中： #：没有则为空 0：没有则补0 二、进制转换：8–>16,可以先转为10进制，再转为十六进制 ///String str4 = Integer.toString(i,x) ; ///10进制的数字i转换成x进制的字符串 /// System.out.println(Integer.parseInt(“对应进制格式”,这个字符串是多少进制));
蓝桥杯总结-常用函数及算法
weixin_30511039的博客
06-20 1988
<memory.h>或<string.h> void *memset(void *s, int ch,size_tn); #include <algorithm> sort(a,a+n)排序函数，从小到大，a为数组名字，n为元素个数 sort(vector.begin(),vector.end())排序vector 只要数据类型定义了小于操作...
蓝桥杯算法知识及练习题.zip_算法 蓝桥杯_蓝桥杯_蓝桥杯入门题_蓝桥杯算法题
09-21
这些题目不仅考验你的编程技巧，还要求你具备深厚的算法理论基础。 学习这个资源，你需要逐步理解和实践每一个算法，通过不断地练习，形成对算法的直觉和熟练度。同时，参加蓝桥杯比赛可以提供一个实战平台，让你在...
蓝桥杯c++-蓝桥杯竞赛练习之算法提高题多项式输出.zip
最新发布
04-12
【标题】"蓝桥杯c++-蓝桥杯竞赛练习之算法提高题多项式输出"主要涉及的是在C++编程语言环境下，针对蓝桥杯竞赛中的算法问题进行的专项训练，特别是关于多项式输出的技巧和方法。在编程竞赛中，理解和高效实现多项式...
蓝桥杯-蓝桥杯经典赛题算法题之最小生成树.zip
03-04
在蓝桥杯算法竞赛中，理解并掌握最小生成树的求解方法至关重要。常见的两种算法是Prim算法和Kruskal算法。 1. Prim算法：该算法从一个顶点开始，逐步增加边，每次增加一条使得当前树与未加入树的顶点之间权值最小的...
蓝桥杯算法学习整理
种一棵树最好的时间是十年前，其次是现在。
03-12 8120
报名了蓝桥杯，但是对于算法的基础却不是很好，收集了一些学习的链接，以下链接都是转载自别人名下的博客文章，如果博主介意的话，请通知我立即删除。 供日后复习时使用： 前部分是摘录自：庞俊伟的博客 1.Java十进制数与其余进制数转换问题 2.进制转化知识完成各进制之间的转化 3.JAVA高精度数值运算方法，小数点后保留位数，结合相关例题进行介绍！ 4.JAVA全排列 （这个有点理解不...
【蓝桥杯】最难算法没有之一· 动态规划真的这么好理解？（引入）
热门推荐
安然无虞的博客
12-19 3万+
【前言】 在学习动态规划之前，我们必须要先掌握记忆化搜索和递推，这两块东西搞好了之后，面对动态规划那就容易多啦！好，接下来向铁汁们详细介绍这两块内容，走着。 一、记忆化搜索 提问： 何为记忆化搜索？ 回答： 顾名思义，记忆化搜索肯定也就和“搜索”脱不了关系了，前面的DFS和BFS想必大家都已经掌握的差不多了，它们有个最大的弊病就是：低效！原因在于没有很好地处理重叠子问题。那么对于记忆化搜索呢，它虽然采用搜索的形式，但是它还有动态规划里面递推的思想，巧就巧在它将这两种方法很好的综合在了.
蓝桥杯算法全家桶（终极完结版）
JohnnyLin
06-11 1万+
蓝桥杯考察范围： 蓝桥杯算法合集这个系列包括： 蓝桥杯常用算法系列 蓝桥杯五年真题两次模拟系列 算法竞赛Java常用API总结 以及 常用数据结构 这四个模块，里面的算法题目大多是蓝桥杯历届真题。文章都是是自己备战学习过程中总结出来的，这里一并贴出，方便大家学习和交流。 个人水平有限，文章中有错误的地方还请大佬们在评论区指出或私信，方便改正，以免以谬传谬，在此先谢过了。 蓝桥杯算法合集蓝桥杯常用算法系列蓝桥杯五年真题两次模拟系列五年真题两次模拟算法竞赛Java常用API总结常用数据结构算法书籍分享 蓝桥
蓝桥杯算法考前复习要点和归纳总结
星辰大数据的博客
07-09 1万+
一、重要知识要点 1、穷举法 2、枚举法 3、动态规划 4、回溯法 5、图论 6、深度优先搜索（DFS） 7、广度优先搜索（BFS ） 8、二叉树 9、递归 10、分治法、矩阵法 11、排列组合 12、素数、质数、水仙花数 13、欧几里得定理gcd 14、求最大公约数、最小公倍数 15、海伦公式（求三角形面积） 16、博弈论 17、贪心...
百度笔试：回家有n个台阶，每次至少走一个，但是要求每步和之前两步走的台阶数目不能一样，请问有多少种不同的解法，答案对10^9+7取模。
CAFE-BABE的博客
09-04 4562
回家有n个台阶，每次至少走一个，但是要求每步和之前两步走的台阶数目不能一样，请问有多少种不同的解法，答案对10^9+7取模。 输入两个整数n，m，n表示台阶数目，m表示单步最大跨越的台阶数目。 思路：老实说这题不难，但是想全A还是有点难，全A肯定要动态规划，而且是三维的动态规划，但是我觉得面试的时候也不会考这么难，所以三维的动态规划的方法就不写了，下面写了两个方法，一个是递归的，一个是记忆化搜索（带备忘录的递归）。 1、递归 就是递归每次需要传入上一次的值last和上上次的值lastlast，然后遍
LeetCode55. 跳跃游戏
长弓smile的博客
06-06 885
LeetCode55. 跳跃游戏 给定一个非负整数数组，你最初位于数组的第一个位置。 数组中的每个元素代表你在该位置可以跳跃的最大长度。 判断你是否能够到达最后一个位置。 示例 1: 输入: [2,3,1,1,4] 输出: true 解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。 示例 2: 输入: [3,2,1,0,...
蓝桥杯 | 总结几个重要函数！！！
OneLine_的博客
03-23 6546
四个重要的STL函数！！！ unique lower_bound bitset next_permutation
蓝桥杯算法特训 | C++ | 暴力破解与实用性优先
Shannon
03-06 2470
课程主要内容    暴力破解与实用性优先    （1）暴力破解在大赛及企业应用中的重要性    （2）暴力破解中的实用性原则    （3）逆向解法    （4）枚举法关键词：枚举（情况少的时候）、逆向解法（逆算）、试探观察（试解）1.年龄谜题：    美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。他曾在1935~1936年应邀来中国清华大学讲学。 一次，他参加某个重要会议，年轻的脸...
蓝桥杯比赛常考算法_蓝桥杯常用知识点+算法汇总
weixin_35698069的博客
12-31 3967
1. %.3f保留3位小数并四舍五入2. &&的优先级要高与||和&&有点类似于*，||类似于+3：1 if(1)2 if(b)3 x++;4 else //else默认和最近的一个if配对5 y++;4. if(fabs(m*my-n*ny)<0.000001)//浮点数判断相...
蓝桥杯python小学组学哪些算法？
06-12
蓝桥杯小学组的 Python 竞赛主要涉及以下几个方面的算法： 1. 算法思想：简单的贪心算法、暴力枚举、模拟等。 2. 数据结构：基本的数据结构，如数组、列表、字符串等，以及它们的基本操作。 3. 算法实战：简单的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值