前言
因为笔者最近在准备 蓝桥杯 算法竞赛，这段时间学习了众多的算法知识，其中不乏有
快速幂、bfs、dfs、全排列等常用的算法技巧和模板。而很多的算法题目其实都是有规律可循的，有一定的模板可以套用，因此笔者在这里以笔记的形式对这些模板和技巧进行记录，以便后面的复习使用~！！（若读者对笔者列出的模板代码有更好的优化建议，也欢迎在评论区中提出）
前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家，点击跳转到网站
1.数学
1.1.最大公约数
例题：https://www.lanqiao.cn/problems/593/learning/
// 求最大公约数：如 12 和 18 的最大公约数是 6；
public int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
1.2.最小公倍数
// 求最小公倍数：如 2 和 3 的最小公倍数为 6；
public int lcm(int a, int b) {
return a * b / gcd(a, b);
}
1.3.拓展欧几里得
用于解二元一次不定方程：ax + by = c
private static int x, y;
public static int exgcd(int a, int b) {
if(b == 0) {
x = 1;
y = 0;
return a;
}
int c = exgcd(b, a % b);
int z = x;
x = y;
y = z - a / b * y;
return c;
}
以上公式皆摘抄自博主执梗的原创文章：【蓝桥真题3】蓝桥改革变难，想进国赛这些能力你可缺一不可
1.4.快速幂
我们虽然可以使用Java数学包下的Math.pow方法来求出x的n次幂的值，但这个函数本身运行起来是非常耗时的，对于我们需要参加竞赛的读者来说，无疑会让我们在超时的边缘徘徊，而快速幂可以通过将指数拆分成多个因数相乘的形式来简化幂运算，大大调高运算效率，可谓是我们的一大得力帮手！
例题：https://leetcode-cn.com/problems/powx-n/
// x为底数，n为幂数
public double myPow(double x, int n) {
double result = 1;
long v = n;
if(v < 0) {
x = 1 / x;
v = -v;
}
while(v > 0) {
if((v & 1) == 1) {
result *= x;
}
v >>= 1;
x *= x;
}
return result;
}
1.5.埃筛法
埃筛法是能够快速筛选出质数的方法之一，在众多质数筛选方法中，埃筛法虽然不是最快的方法，但绝对是最容易理解的方法。
原理： 从小到大开始筛选质数，当某个数被认定为质数时，那么后面能够被该数整除的数就一定不是质数，为这些数增加一个标记，当遍历到这些被标记的数时，直接跳过即可，无需再为其执行检验是否为质数的操作，因为判断一个数是否为质数是筛选质数过程中最耗时的操作，而埃筛法则能大幅度的减少该操作的执行频率，从而提高素数筛选的效率。
// 求n下有多少个质数
public static void main(String[] args) {
int n = 100;
boolean[] flag = new boolean[n + 1];
for(int i = 2; i <= n; i++) {
if(flag[i]) continue;
System.out.println(i);
for(int j = i; i * j <= n; j++) {
flag[i * j] = true;
}
}
}
1.6.判断丑数
丑数即因数只有2, 3, 5的数，那么我们对一个数n一直除以2，3，5后，若最后n = 1，很明显这个数n就属于丑数，否则就不是丑数。
例题：https://leetcode-cn.com/problems/ugly-number/
public boolean isUgly(int n) {
if(n < 1) {
return false;
}
while (n % 5 == 0) {
n /= 5;
}
while (n % 3 == 0) {
n /= 3;
}
while (n % 2 == 0) {
n /= 2;
}
return n == 1;
}
1.7.保留小数
// 保留两位小数
String.format("%.2f", n);
1.8.进制转换
int x = 1040063, n = 36;
// n进制转为十进制
Integer.valueOf("MAIN", n); // 1040063
// 十进制转为n进制
Integer.toString(x, n); // main
2.日期
对于日期问题，最让我们头疼的应该就是要考虑年份是否为闰年，即2月份应该是28天还是29天，其他月份的天数是30天还是31天等问题。
经典的问题还有：从某个日期开始到另一个日期相差了多少天；从某个日期开始到另一个日期开始有多少个星期一等，需要做许多的判断。但如果你熟练的掌握了Java内置的与时间处理相关的类，那么这些问题都将不再会是你的烦恼~！
2.1.两个日期相差的天数
// 求2022-2-1到2022-3-1相差的天数
public static void main(String[] args) {
LocalDateTime time1 = LocalDateTime.of(2022, 2, 1, 0, 0);
LocalDateTime time2 = LocalDateTime.of(2022, 3, 1, 0, 0);
long result = Duration.between(time1, time2).toDays(); // 28
}
2.2.遍历某段日期的每一天
例题：https://www.lanqiao.cn/problems/597/learning/
// 遍历2022-01-01到2022-03-01这段日期中的每一天
public static void main(String[] args) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar calendar = Calendar.getInstance();
// 2022-01-01（注意：这里月份需要减一）
calendar.set(2022, 2 - 1, 1);
// 2022-03-01
while("2022-03-01".equals(sdf.format(calendar.getTime()))) {
// ...
calendar.add(Calendar.DAY_OF_MONTH, 1);
}
}
3.二分
class Solution {
public int search(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
while(left <= right) {
int mid = left + (right - left)/2;
if(target == nums[mid]) {
return mid;
}
if(target > nums[mid]) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}
}
4.位运算技巧
4.1.英文字符转换为小写
('a' | ' ') = 'a'
('A' | ' ') = 'a'
4.2.英文字符转换为大写
('b' & '_') = 'B'
('B' & '_') = 'B'
4.3.英文字符大小写互换
('d' ^ ' ') = 'D'
('D' ^ ' ') = 'd'
4.4.判断两个数是否异号
int x = -1, y = 2;
// 同号为true，异号为false；
boolean flag = ((x ^ y) < 0);
4.5.找出在0~n中缺少的一个数
原理： a ^ b ^ a = b
public static int missingNumber(int[] nums) {
int result = nums.length;
for(int i = 0; i < nums.length; i++) {
result ^= nums[i];
result ^= i;
}
return result;
}
5.深搜广搜
5.1.深度优先搜索（dfs）
例题：https://leetcode-cn.com/problems/sudoku-solver/
// 访问标记，防止走回头路
private boolean[][] visited;
public void dfs(char[][] grid, int i, int j) {
int n = grid.length;
// 边界判断，以及判断是否已经被访问过了
if(i < 0 || j < 0 || i >= n || j >= n || visited[i][j]) {
return;
}
// 开始对上、下、左、右四个方向进行选择
visited[i][j] = true;
// ......
dfs(grid, i + 1, j);
dfs(grid, i - 1, j);
dfs(grid, i, j + 1);
dfs(grid, i, j - 1);
// 撤销选择
visited[i][j] = false;
}
5.2.广度优先搜索（bfs）
BFS主要用于解决最短路径的问题，比如最经典的迷宫最优路径问题，使用BFS就再合适不过了。
例题：https://www.lanqiao.cn/problems/1216/learning/
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int m = scanner.nextInt();
int[][] grid = new int[n][m];
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
grid[i][j] = scanner.nextInt();
}
}
// 起点坐标
int si = scanner.nextInt() - 1;
int sj = scanner.nextInt() - 1;
// 终点坐标
int ei = scanner.nextInt() - 1;
int ej = scanner.nextInt() - 1;
scanner.close();
// 对应下、上、右、左的移动方向
int[][] moves = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
Queue<Node> queue = new LinkedList<>();
// 将起点压入队列中
queue.offer(new Node(si, sj, 0));
// 将起点标记为已访问
grid[si][sj] = 0;
while(!queue.isEmpty()) {
Node node = queue.poll();
// 如果当前节点是终点，则输出在迷宫走的步数
if(node.i == ei && node.j == ej) {
System.out.println(node.count);
return;
}
// 开始遍历上下左右
for(int[] move : moves) {
int k = node.i + move[0];
int v = node.j + move[1];
// 如果当前方向已经被访问过，或者存在墙，则跳过
if(k < 0 || v < 0 || k >= n || v >= m || grid[k][v] == 0) {
continue;
}
// 将该方向下的节点存入队列中
queue.offer(new Node(k, v, node.count + 1));
// 并将该节点设置为已访问
grid[k][v] = 0;
}
}
System.out.println(-1);
}
}
class Node {
int i, j, count;
public Node(int i, int j, int count) {
this.i = i;
this.j = j;
this.count = count;
}
}
6.全排列
例题：https://www.lanqiao.cn/problems/731/learning/
// 需要进行排列的数字
private static int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9};
// 符合排列要求的结果数
private static int count = 0;
public static void main(String[] args) {
dfs(0); // 从第一个数开始
System.out.println(count);
}
public static void dfs(int i) {
if(i == nums.length) {
check();
return;
}
for(int j = i; j < nums.length; j++) {
swap(i, j); // 置换数字位置
dfs(i + 1); // 排列下一位
swap(i, j); // 还原数字位置
}
}
// 检查排列后是否符合题目要求
public static void check() {
int a = nums[0] * 100 + nums[1] * 10 + nums[2];
int b = nums[3] * 100 + nums[4] * 10 + nums[5];
int c = nums[6] * 100 + nums[7] * 10 + nums[8];
if(a + b == c) {
count++;
}
}
// 对数组中的数进行位置的替换，可以保证排列后的数都是不相同的数
public static void swap(int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
7.并查集
例题：https://www.lanqiao.cn/problems/1135/learning/
private static int[] set;
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int m = scan.nextInt();
set = new int[n + 1];
init();
int[][] nums = new int[m][3];
for(int i = 0; i < m; i++) {
nums[i][0] = scan.nextInt();
nums[i][1] = scan.nextInt();
nums[i][2] = scan.nextInt();
}
for(int[] num : nums) {
if(num[0] == 1) {
join(num[1], num[2]);
} else {
int k = find(num[1]);
int v = find(num[2]);
System.out.println(k == v ? "YES" : "NO");
}
}
scan.close();
}
// 初始化
public static void init() {
for(int i = 0; i < set.length; i++) {
set[i] = i;
}
}
// 合并
public static void join(int i, int j) {
int k = find(i);
int v = find(j);
if(k != v) set[k] = v;
}
// 查根
public static int find(int i) {
return set[i] == i ? i : (set[i] = find(set[i]));
}
8.前缀和
8.1.一维前缀和
例题：https://leetcode-cn.com/problems/range-sum-query-immutable/
private int[] preSum;
public NumArray(int[] nums) {
preSum = new int[nums.length + 1];
for(int i = 1; i <= nums.length; i++) {
preSum[i] = preSum[i - 1] + nums[i - 1];
}
}
public int sumRange(int left, int right) {
return preSum[right + 1] - preSum[left];
}
8.2.二维前缀和
例题：https://leetcode-cn.com/problems/range-sum-query-2d-immutable/
private int[][] preSum;
public NumMatrix(int[][] matrix) {
int n = matrix.length, m = matrix[0].length;
if(n == 0 || m == 0) {
return;
}
preSum = new int[n + 1][m + 1];
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= m; j++) {
preSum[i][j] = preSum[i - 1][j] + preSum[i][j - 1] + matrix[i - 1][j - 1] - preSum[i - 1][j - 1];
}
}
}
public int sumRegion(int row1, int col1, int row2, int col2) {
return preSum[row2 + 1][col2 + 1] - preSum[row1][col2 + 1] - preSum[row2 + 1][col1] + preSum[row1][col1];
}
9.动态规划
9.1.背包问题
背包问题是最经典的动态规划问题，这里笔者给出01背包和完全背包的模板，这两个背包问题的区别只在于前者每个物体只可以选择一次，而后者则可以无限重复选择，因此在01背包不考虑空间优化的前提下，它们的实现代码仅有一行只差~！
0 - 1背包：https://www.acwing.com/problem/content/2/
完全背包：https://www.acwing.com/problem/content/3/
多重背包：https://www.acwing.com/problem/content/4/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int m = scanner.nextInt();
int[] vs = new int[n + 1]; // 每个物体的体积
int[] ws = new int[n + 1]; // 每个物体的重量
for(int i = 1; i <= n; i++) {
vs[i] = scanner.nextInt();
ws[i] = scanner.nextInt();
}
int[][] dp = new int[n + 1][m + 1];
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= m; j++) {
// 对当前物体不做选择，那么当前背包的重量应与上一次选择时的重量相同
dp[i][j] = dp[i - 1][j];
// 如果背包剩余的体积大于当前物体的体积，则做出选择
if(j >= vs[i]) {
// 01背包
dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - vs[i]] + ws[i]);
// 完全背包
// dp[i][j] = Math.max(dp[i][j], dp[i][j - vs[i]] + ws[i]);
}
}
}
System.out.println(dp[n][m]);
}
9.2.打家劫舍
打家劫舍1：https://leetcode-cn.com/problems/house-robber/
打家劫舍2：https://leetcode-cn.com/problems/house-robber-ii/
打家劫舍3：https://leetcode-cn.com/problems/house-robber-iii/
/*
* “打家劫舍1”的实现代码如下
*/
private int[] memo;
public int rob(int[] nums) {
memo = new int[nums.length];
Arrays.fill(memo, -1);
return dp(nums, 0);
}
public int dp(int[] nums, int i) {
if(i >= nums.length) {
return 0;
}
if(memo[i] != -1) {
return memo[i];
}
memo[i] = Math.max(
dp(nums, i + 1),
dp(nums, i + 2) + nums[i]
);
return memo[i];
}
9.3.石子合并
例题：https://www.lanqiao.cn/problems/545/learning/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[][] dp = new int[n + 1][n + 1];
int[] nums = new int[n + 1];
for(int i = 1; i <= n; i++) {
nums[i] = nums[i - 1] + scanner.nextInt();
}
for(int[] d : dp) {
Arrays.fill(d, Integer.MAX_VALUE);
}
for(int len = 1; len <= n; len++) {
for(int i = 1; i + len - 1 <= n; i++) {
int j = i + len - 1;
if(len == 1) {
dp[i][j] = 0;
}
for(int k = i; k <= j - 1; k++) {
dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k + 1][j] + nums[j] - nums[i - 1]);
}
}
}
System.out.println(dp[1][n]);
}
9.4.最长序列
最长公共子序列：https://leetcode-cn.com/problems/longest-common-subsequence/
最长连续序列：https://leetcode-cn.com/problems/longest-consecutive-sequence/
最长递增子序列：https://leetcode-cn.com/problems/longest-increasing-subsequence/
最长连续递增序列：https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence/
最长回文子串：https://leetcode-cn.com/problems/longest-palindromic-substring/
最长回文子序列：https://leetcode-cn.com/problems/longest-palindromic-subsequence/
编辑距离：https://leetcode-cn.com/problems/edit-distance/
/*
* “最长公共子序列”的实现代码如下
*/
public int longestCommonSubsequence(String text1, String text2) {
int m = text1.length(), n = text2.length();
int[][] dp = new int[m + 1][n + 1];
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
return dp[m][n];
}
9.5.n的k拆分方案
例题： 求将正整数n无序拆分成最大数为k（称为n的k拆分）的拆分方案个数，要求所有的拆分方案不重复。
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int k = scanner.nextInt();
int[][] dp = new int[n + 1][k + 1];
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= k; j++) {
if(i == 1 && j == 1) {
dp[i][j] = 1;
} else if(i < j) {
dp[i][j] = dp[i][i];
} else if(i == j) {
dp[i][j] = dp[i][j - 1] + 1;
} else {
dp[i][j] = dp[i][j - 1] + dp[i - j][j];
}
}
}
System.out.println(dp[n][k]);
}
10.快读模板
面对大输入量的题目，使用常规的Scanner类来完成输入操作，就会出现超时或者超内存的情况，此时可以使用如下快读模板避免这一情况的发生。
public class Main {
private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private static StreamTokenizer st = new StreamTokenizer(reader);
private static int nextInt() throws IOException {
st.nextToken();
return (int) st.nval;
}
private static long nextLong() throws IOException {
st.nextToken();
return (long) st.nval;
}
private static double nextDouble() throws IOException {
st.nextToken();
return (double) st.nval;
}
private static String next() throws IOException {
st.nextToken();
return st.sval;
}
}
对于常用的算法模板和技巧就分享到这里了，若上述模板存在任何问题或有所补充，欢迎各位读者在下方提出 ~ ！！此篇文章将持续更新 ~ ！！
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
