【算法练习】日常刷题记录

已于 2022-02-21 22:12:03 修改
阅读量299 收藏
点赞数
分类专栏： 算法练习 文章标签： 算法 深度优先 java
于 2022-02-20 20:52:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mxeron/article/details/123029742
版权

一、递归与递推

递归实现指数型枚举

在这里插入图片描述

import java.util.*;

public class Main {
    static int n;
    static LinkedList<Integer> tmp = new LinkedList<>();
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        dfs(1);
    }
    static void dfs(int start) {
        if (tmp.size() == 0) {
            System.out.println();
        }
        if (tmp.size() >= 1) {
            for (int i = 0; i < tmp.size(); i++) {
                System.out.printf("%d ", tmp.get(i));
            }
            System.out.println();
        }
        if (tmp.size() > n) {
            return;
        }
        for (int i = start; i <= n; i++) {
            tmp.add(i);
            dfs(i + 1);
            tmp.removeLast();
        }
    }
}
递归实现排列型枚举

在这里插入图片描述

import java.util.*;

public class Main {
    static int n;
    static int[] vis = new int[10];
    static LinkedList<Integer> tmp = new LinkedList<>();
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        dfs();
    }
    static void dfs() {
        if (tmp.size() == n) {
            for (int i = 0; i < tmp.size(); i++) {
                System.out.printf("%d ", tmp.get(i));
            }
            System.out.println();
        }
        if (tmp.size() > n) {
            return;
        }
        for (int i = 1; i <= n; i++) {
            if (vis[i] == 1) {
                continue;
            }
            vis[i] = 1;
            tmp.add(i);
            dfs();
            vis[i] = 0;
            tmp.removeLast();
        }
    }
}

用System.out.println会超时，改用BufferedWriter，比System.out.println快20倍。

package Chapter_5;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.*;

public class Main {
    static int n;
    static int[] vis = new int[10];
    static LinkedList<Integer> tmp = new LinkedList<>();
    // 加快打印速度
    static BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) throws IOException {
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        dfs();
        log.flush();
    }
    static void dfs() throws IOException {
        if (tmp.size() == n) {
            for (int i = 0; i < tmp.size(); i++) {
                log.write(tmp.get(i) + " ");
            }
            log.write("\n");
        }
        if (tmp.size() > n) {
            return;
        }
        for (int i = 1; i <= n; i++) {
            if (vis[i] == 1) {
                continue;
            }
            vis[i] = 1;
            tmp.add(i);
            dfs();
            vis[i] = 0;
            tmp.removeLast();
        }
    }
}
递归实现组合型枚举

在这里插入图片描述

import java.io.*;
import java.util.*;

public class Main {
    static int n;
    static int m;
    static LinkedList<Integer> tmp = new LinkedList<>();
    // 加快打印速度
    static BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) throws IOException {
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        m = scan.nextInt();
        dfs(1);
        log.flush();
    }
    static void dfs(int start) throws IOException {
        if (tmp.size() == m) {
            for (int i = 0; i < tmp.size(); i++) {
                log.write(tmp.get(i) + " ");
            }
            log.write("\n");
        }
        if (tmp.size() > m) {
            return;
        }
        for (int i = start; i <= n; i++) {
            tmp.add(i);
            dfs(i + 1);
            tmp.removeLast();
        }
    }
}
飞行员兄弟

在这里插入图片描述
在这里插入图片描述
从左到右，从上往下，依次遍历每个开关，对某个开关有两种状态，可以change，也可以不change，所以就需要回溯。

import java.io.*;
import java.util.*;

class node {
    int x, y;
    node() {};
    node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Main {
    static char[][] map = new char[4][4];
    static LinkedList<node> nodes = new LinkedList<>();
    static LinkedList<node> ans = new LinkedList<>();
    // 加快打印速度
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        for (int i = 0; i < 4; i++) {
            map[i] = scan.next().toCharArray();
        }
        // 从左到右、从上到下遍历每个开关，直到遍历完，整个过程中查看是否成功
        dfs(0, 0);
        System.out.println(ans.size());
        for (int i = 0; i < ans.size(); i++) {
            System.out.printf("%d %d\n", ans.get(i).x + 1, ans.get(i).y + 1);
        }
    }
    static void openOneUp(int x, int y) {
        if (map[x][y] == '+') map[x][y] = '-';
        else map[x][y] = '+';
    }
    static void openAllUp(int x, int y) {
        for (int i = 0; i < 4; i++) {
            openOneUp(x, i);
            openOneUp(i, y);
        }
        // 注意上面会把x,y重置（两次change = 不change）
        // 还需要单独open(x,y)
        openOneUp(x, y);
    }
    static void dfs(int x, int y) {
        if (x == 3 && y == 4) {
            // 所有开关都遍历完了，看当前冰箱能否打开
            boolean flag = true;
            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < 4; j++) {
                    if (map[i][j] == '+') {
                        flag = false;
                        break;
                    }
                }
                if (flag == false) {
                    break;
                }
            }
            if (flag) {
                // 所需的最小切换把手次数
                if (ans.isEmpty() || ans.size() > nodes.size()) {
                    // 必须要用clone，否则nodes的变化会导致ans的变化
                    ans = (LinkedList<node>) nodes.clone();
                }
            }
            return;
        }
        // 当前行遍历完了，遍历下一行
        if (y == 4) {
            x++;
            y = 0;
        }
        openAllUp(x, y);
        node tmp = new node(x, y);
        nodes.add(tmp);
        // 遍历右边一个
        dfs(x, y + 1);
        // 回溯
        nodes.removeLast();
        // 回溯，之前的状态也要全部回溯
        openAllUp(x, y);
        dfs(x, y + 1);
    }
}

二、二分

数的范围

在这里插入图片描述
一次二分找最开始位置，一次二分找第一个大于它的位置即可。

import java.io.*;
import java.util.*;

public class Main {
    static int[] nums;
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int q = scan.nextInt();
        nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = scan.nextInt();
        }
        for (int i = 0; i < q; i++) {
            int key = scan.nextInt();
            int res = binarySearch(key);
            if (res == -1) {
                System.out.printf("-1 -1\n");
            } else {
                int res1 = binarySearch1(key);
                System.out.printf("%d %d\n", res, res1 - 1);
            }
        }
    }
    static int binarySearch(int key) {
        int res = -1;
        int left = 0;
        int right = nums.length - 1;
        int mid;
        while (left <= right) {
            mid = left + (right - left) / 2;
            if (nums[mid] == key) {
                res = mid;
                // 要找第一次出现的位置
                right = mid - 1;
            } else if (nums[mid] > key) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return res;
    }
    // 找第一个大于key的下标
    static int binarySearch1(int key) {
        int left = 0;
        int right = nums.length;
        int mid;
        while (left < right) {
            mid = left + (right - left) / 2;
            if (nums[mid] > key) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }
}
数的三次方根

在这里插入图片描述
从n的左右边界开始遍历

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        double key = scan.nextDouble();
        // 注意x的范围可正可夫，所以左右边界要为边界
        double left = -10000;
        double right = 10000;
        double eps = 0.00000001;
        double mid;
        while (right - left >= eps) {
            mid = left + (right - left) / 2;
            if (mid * mid * mid <= key) {
                left = mid;
            } else {
                right = mid;
            }
        }
        System.out.printf("%.6f", left);
    }
}

能用二分的地方，都是存在单调性的地方！

三、模拟

在这里插入图片描述
注意不能斜向走，找到两个坐标，然后求曼哈顿距离。

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int w = scan.nextInt();
        int m = scan.nextInt();
        int n = scan.nextInt();
        m--;n--;
        int x1 = m / w;
        int x2 = n / w;
        int y1 = m % w;
        if (x1 % 2 == 0) {
            y1 = w - y1 - 1;
        }
        int y2 = n % w;
        if (x2 % 2 == 0) {
            y2 = w - y2 - 1;
        }
        System.out.println(Math.abs(x1 - x2) + Math.abs(y1 - y2));
    }
}

四、搜索

被围绕的区域（中等）

在这里插入图片描述
这道题可以用DFS，代码如下：

class Solution {
    static int m, n;
    public void solve(char[][] board) {
        // 先把边上的o全部遍历标记为A，然后再全局dfs，标记o为X
        // 最后把A换为o，剩下的o换为X
        m = board.length;
        n = board[0].length;
        for (int i = 0; i < m; i++) {
            dfs(board, i, 0);
            dfs(board, i, n - 1);
        }
        for (int i = 0; i < n; i++) {
            dfs(board, 0, i);
            dfs(board, m - 1, i);
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                } else if (board[i][j] == 'A') {
                    board[i][j] = 'O';
                }
            }
        }
    }
    void dfs(char[][] board, int x, int y) {
        if (x < 0 || y < 0 || x >= m || y >= n) {
            return;
        }
        if (board[x][y] == 'X' || board[x][y] == 'A') {
            return;
        }
        if (board[x][y] == 'O') {
            board[x][y] = 'A';
        }
        dfs(board, x + 1, y);
        dfs(board, x - 1, y);
        dfs(board, x, y + 1);
        dfs(board, x, y - 1);
    }
}
献给阿尔吉侬的花束

在这里插入图片描述
献给阿尔吉侬的花束

正常的BFS，直接做就行。

import java.util.*;

class node {
    int x, y, step;
    node() {};
    node(int x, int y, int step) {
        this.x = x;
        this.y = y;
        this.step = step;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int t = scan.nextInt();
        char[][] map;
        int[][] vis;
        int[] xx = new int[] {-1,1,0,0};
        int[] yy = new int[] {0,0,-1,1};
        for (int i = 0; i < t; i++) {
            int r = scan.nextInt();
            int c = scan.nextInt();
            vis = new int[201][201];
            map = new char[201][201];
            node b = new node();
            for (int j = 0; j < r; j++) {
                map[j] = scan.next().toCharArray();
                for (int k = 0; k < c; k++) {
                    if (map[j][k] == 'S') {
                        b = new node(j, k, 0);
                        vis[j][k] = 1;
                    }
                }
            }
            int ans = Integer.MAX_VALUE;
            Queue<node> Q = new LinkedList<>();
            Q.offer(b);
            while (!Q.isEmpty()) {
                node tmp = Q.poll();
                if (map[tmp.x][tmp.y] == 'E') {
                    ans = tmp.step;
                    break;
                }
                for (int j = 0; j < 4; j++) {
                    // 注意这里不要直接temp = tmp!!!
                    node temp = new node();
                    temp.x = tmp.x + xx[j];
                    temp.y = tmp.y + yy[j];
                    if (temp.x < 0 || temp.y < 0 || temp.x >= r || temp.y >= c || map[temp.x][temp.y] == '#') {
                        continue;
                    }
                    if (vis[temp.x][temp.y] == 1) {
                        continue;
                    }
                    vis[temp.x][temp.y] = 1;
                    temp.step = tmp.step + 1;
                    Q.offer(temp);
                }
            }
            if (ans == Integer.MAX_VALUE) {
                System.out.println("oop!");
            } else {
                System.out.println(ans);
            }
        }
    }
}

五、前缀和

在这里插入图片描述
普通的前缀和要超时，让女生=-1，男生=1，这样记录前缀和中每个和第一次出现的位置，后面再遇到同样的和时，减去第一次出现的位置即可。需要注意，可能有从头到某个位置只有1个零出现的情况，例如：1 1 -1 -1，前缀和为：1 2 1 0，只有1个0，所以需要在读入数据的时候单独求和判断一下。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        // 计算前缀和，比较当前区间和区间长度是否相等
        int[] nums = new int[n];
        int sum = 0;
        int ans = 0;
        for (int i = 0; i < n; i++) {
            nums[i] = scan.nextInt();
            if (nums[i] == 0) {
                nums[i] = -1;
            }
            sum += nums[i];
            if (sum == 0) {
                // 如果从头到某个位置的和为0，且只出现1次，要特殊判断一下
                ans = i + 1;
            }
        }
        // 计算前缀和
        int[] preSum = new int[n + 1];
        int[] pos = new int[2 * n + 1];
        for (int i = 1; i <= n; i++) {
            preSum[i] = preSum[i - 1] + nums[i - 1];
            if (pos[preSum[i] + n] != 0) {
                ans = Math.max(i - pos[preSum[i] + n], ans);
            } else {
                pos[preSum[i] + n] = i;
            }
        }
        System.out.println(ans);            
    }
}

这道题滑动窗口做不了。

@u@
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
程序设计与算法（二）算法基础课--1、枚举 python实现
ciecus_csdn的博客
02-10 1752
程序设计与算法（二）算法基础课--1、枚举 python实现题1:完美立方解题思路：python代码：题2:生理周期解题思路：python代码：题3: 假币问题解题思路python代码题4: 熄灯问题解题思路python代码 程序设计与算法（二）算法基础课–1、枚举 python实现 课程源自mooc网，北京大学郭炜老师的课程，这里只是作为课程笔记分享，原课程使用c++实现，这里用python实现...
c++算法练习
m0_61896578的博客
01-12 512
问题描述 题目描述 若一个数（首位不为零）从左向右读与从右向左读都一样，我们就将其称之为回文数。 例如：给定一个十进制数56，将56加65（即把5656从右向左读），得到121是一个回文数。 又如：对于十进制数87： STEP1：87+78=165 STEP2：165+561=726 STEP3：726+627=1353 STEP4：1353+3531=4884 在这里的一步是指进行了一次N进制的加法，上例最少用了4步得到回文数4884。 写一个程序，给定一个N（2≤N≤10...
基础算法练习43道（详细讲解版，随时更新）
qq_36657788的博客
02-20 4715
本算法是基础算法，既然是基础算法，既可以用java语言编写，也可以用C等其它语言编写，所以我建议想学C语言的同学，可以去看我的博客 《C语言各章节干货汇总、考研知识点归纳》，之后也可以用C语言编写，想用C练习的小伙伴，只需要将方法体中输入输出语句改为C语言输入输出语句即可，另外有些改不了的我会给出C算法的代码。
买卖股票的最佳时机 leetcode java篇
weixin_51666505的博客
03-30 825
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 两种方法,动态规划+暴力解法 class Solution { public int maxProfit(int[] prices){ int len = pri.
算法练习集合
weixin_44081096的博客
06-08 318
1.移除元素 1、给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。 2、 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 3、元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。 解题： package SuanFa.Array; import java.util.Arrays; public class removeElement { public static void main
labuladong的算法秘籍+刷题笔记V2.0
09-17
labuladong系列刷题三件套，计算机leetcode刷题，找工作提升编程能力。
算法：leetcode刷题记录
02-17
算法：leetcode刷题记录
JavaScript数据结构与算法即LeetCode刷题记录.zip
12-27
大数据算法在数据分析中发挥着重要的作用，它可以提高分析工作的效率和准确性，为决策提供有力支持。具体来说，大数据算法可以分类、聚类、预测和关联规则分析等，从而发现数据之间的规律和关联关系，挖掘出潜在的...
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录.zip
最新发布
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
算法经典题目
热门推荐
Maple的博客
09-17 2万+
算法经典题目 1.在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 思路：因为这是一个从左到右递增和从上到下递增的二维数组，例如下： [1,2,3,4] [ 2,3,4,5] [3,4,5,6] 这个数组中的所有数即为1，2，3，4，5，6，所以只要判断t...
算法经典习题大全
06-28
知识点概括全面的算法习题大全，搞定所有这100多道问题，NOIP提高组一等奖指日可待。每道题包含c++和Pascal两种竞赛常用语言的代码，和多组测试数据，方便大家查错。包含9个模块：高精度，排序，递归，递推，贪心，分治，搜索，回溯，动态规划。大家可以阅读代码或自己编写程序来取得进步。欢迎大家下载此资源！
算法练习集锦(一)
changke的博客
02-23 1978
贪心算法 给定一个非负整数数组，你最初位于数组的第一个位置。 数组中的每个元素代表你在该位置可以跳跃的最大长度。 判断你是否能够到达最后一个位置 示例 1: 输入: [2,3,1,1,4] 输出: true 解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。 示例 2: 输入: [3,2,1,0,4] 输出: false 解释: 无论怎样，你总会到达索引为 3 的位置。...
50道经典算法训练（不断更新中。。。）
教主的博客
10-09 1125
经典算法训练（不断更新中。。。） 1.算法训练 1.1到n的求和（不能使用各类关键词） #include<iostream> using namespace std; int qiuhe(int n); int main() { printf("请输入一个数字："); int a; scanf("%d", &a); printf("%d", qiuhe(a)); return 0; } int qiuhe(int n) { if (n <= 0)return 0
算法练习——Multithreading
zm1_1zm
03-15 1132
问题描述 　　现有如下一个算法： 　　repeat ni times 　　yi := y 　　y := yi+1 　　end repeat 　　令n[1]为你需要算加法的第一个数字，n[2]为第二个，...n[N]为第N个数字（N为需要算加法的数字个数）， 　　并令y初始值为0，先令i=1运行这个算法（如上所示，重复n[i]次），然后令i=2运行这个算法。。直到i=N。注意y值一直不
递归算法练习
thegreatmz的博客
05-21 8396
题目：一个人赶着鸭子去每个村庄卖，每经过一个村子卖去所赶鸭子的一半又一只。这样他经过了七个村子后还剩两只鸭子，问他出发时共赶多少只鸭子？经过每个村子卖出多少只鸭子？ 题目分析：经过7个村庄后还剩两只鸡鸭子，每经过一个村庄卖当前鸭子的一半加一只，所以递归体是经过前一个村子的鸭子数除以2再减去1就是到达下一个村子的时候的鸭子数，所以要想求在第一个村子的鸭子数，必须从后往前推。 算法实现： #in
算法练习
老男孩的粉丝团
09-21 153
排列数字（排列坑，回溯） #include<bits/stdc++.h> using namespace std; bool flag[10]; int n; vector<int> vec; void dfs(int be,int ed){ if(be == n){ for(int i =0; i<vec.size(); i++){ cout<<vec[i]<< ' '; .
日常算法练习
Endeavor_No1的博客
07-09 195
简单类 1.给定两个数组，编写一个函数来计算它们的交集。 相关链接：https://juejin.im/post/5f05087cf265da22d466f60f?utm_source=gold_browser_extension
[实战算法] 算法练习题汇总(总章)
Be yourself.
03-05 992
前言 说来惭愧，工作2年多，对于算法方面是一点都没有进步。反而有点退步。本章意在重启当初的算法练习题. 看样子, 当初欠下的技术债还是要还. 练习地址: https://www.nowcoder.com/activity/oj 项目地址: https://github.com/SeanYanxml/arsenal/tree/master/arsenal-java/arsenal-algorithm...
算法训练 麦森数
github_33890270的博客
05-12 2657
问题描述 　　形如2P-1的素数称为麦森数，这时P一定也是个素数。但反过来不一定，即如果P是个素数，2P-1不一定也是素数。到1998年底，人们已找到了37个麦森数。最大的一个是P=3021377，它有909526位。麦森数有许多重要应用，它与完全数密切相关。 　　任务：从文件中输入P（1000#include <stdio.h> #include <math.h> #define MAXBIT
python算法刷题
08-24
当然可以！Python是一种非常适合刷题的编程语言。你可以使用Python来解决...记住，刷题不仅仅是为了解决问题，更重要的是提升你的算法思维和编程能力。多动手实践，多思考优化方案，相信你会不断进步！祝你刷题愉快！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@u@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值