算法题目整合3

已于 2024-07-21 15:45:16 修改
阅读量569 收藏 6
点赞数 16
分类专栏： leetcode 文章标签： 算法 数据结构
于 2024-07-21 15:43:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62571233/article/details/140551489
版权

文章目录

133. 夹吃棋

题目描述

在一个 3 * 3 的棋盘上，小红和小紫正在玩“夹吃棋”。 
所谓“夹吃棋”，即如果存在一个白子，它的两侧 (横向或者纵向)相邻都是黑子，则这个棋子将被“夹吃”，对于黑棋亦然。 
如果一个棋盘的局面没有一方被夹吃，或者黑白双方都被对面夹吃，则认为是平局。如果只有一方夹吃了另一方，则认为夹吃方赢，被夹吃方输。 
小红执黑棋，小紫执白棋，现在给定一个局面，请你判断当前棋局是谁获胜。

输入描述

第一行输入一个正整数 t （1 <= t <= 10000），代表询问的次数。 
接下来每组询问输入三行，，每行是一个长度为3的字符串，字符串仅由'o','.','*'组成。
其中 o 代表白棋，* 代表黑棋，. 代表未放置棋子。

输出描述

小红获胜输出“kou”，小紫获胜输出“yukan”，平局输出“draw”。

输入示例

3
...
o*o
...
o**
ooo
..*
o*o
*o*
o*o

输出示例

yukan
kou
draw

思路：模拟

import java.util.*;
class Main{
    public static void main (String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        char[][] ch = new char[3][3];
        for(int i = 0; i < n; i++){
            for(int j = 0; j < 3; j++){
                String s = sc.next();
                char[] c = s.toCharArray();
                for(int k = 0; k < 3; k++){
                    ch[j][k] = c[k];
                }
            }
            if(determine(ch) == 0){
                System.out.println("yukan");
            }else if(determine(ch) == 1){
                System.out.println("kou");
            }else{
                System.out.println("draw");
            }
        }
    }
    public static int determine(char[][] ch){
        boolean[] flag = new boolean[3];
        for(int i = 0; i < 3; i++){
            for(int j = 0; j < 3; j++){
                if(ch[i][j] == '.')  continue;
                int i1 = i - 1, i2 = i + 1;
                int j1 = j - 1, j2 = j + 1;
                if(i1 >= 0 && i2 < 3){
                    if(ch[i][j] == '*' && ch[i1][j] == 'o' && ch[i2][j] == 'o')  flag[0] = true;
                    if(ch[i][j] == 'o' && ch[i1][j] == '*' && ch[i2][j] == '*')  flag[1] = true;
                }
                if(j1 >= 0 && j2 < 3){
                    if(ch[i][j] == '*' && ch[i][j1] == 'o' && ch[i][j2] == 'o')  flag[0] = true;
                    if(ch[i][j] == 'o' && ch[i][j1] == '*' && ch[i][j2] == '*')  flag[1] = true;
                }
            }
        }
        if(flag[0] && flag[1])  return 2;
        if(flag[0])  return 0;
        if(flag[1])  return 1;
        return 2;
    }
}

134. 小红买药

题目描述

小红准备买药治病。已知共有 n 种症状和 m 种药，第 i 种药可以治疗一些症状，但可能会导致一些副作用，添加一些新的症状。小红依次服用了一些药，请你告诉小红，当她每次服用一副药时，当前还有多少症状？

输入描述

第一行输入一个正整数 n（1 <= n <= 20），代表症状的数量 
第二行输入一个长应为 n 的 01 串，第 i 位是 "1" 代表小红目前有第 i 个症状，第i位是 "0" 代表没有该症状。 
第三行输入一个正整数 m（ 1<= m <= 10^4），代表药的数量。 
接下来的 2 * m 行，每 2 行描述一副药：	
第一行输入一个长度为 n 的 01 串，代表该药能治疗的症状。’1‘代表可以治疗，‘0’代表不能治疗。
第二行输入一个长度为 n 的 01 串，代表该药会产生的副作用。’1‘代表会产生该症状，’0‘代表不会产生。 
接下来的一行，输入一个正整数 q（ 1<= q <= 10^4），代表小红服用的药数量。 
接下来的 q 行，每行输入一个正整数 u（1 <= ai, u <= m），代表小红服用了第 u 副药。
保证每副药的副作用产生的症状和该药治疗的症状是不会重复的，即不会存在同一个位置的两个 01 串都是‘1’。

输出描述

输出 q 行，每行输入一个正整数，代表当前小红服用药后，身体有多少症状。

输入示例

4
0101
3
1100
0010
0101
1000
1001
0000
3
2
3
1

输出示例

1
0
1

模拟

import java.util.*;
class Main{
    public static void main (String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = Integer.parseInt(sc.nextLine());
        String condition = sc.nextLine();
        char[] cond = condition.toCharArray();
        int numOfDrug = Integer.parseInt(sc.nextLine());
        //ch[i][1][k]表示第i种药能够治疗(1)的症状的第k个字符
        char[][][] ch = new char[numOfDrug][3][n];
        for (int i = 0; i < numOfDrug; i++){
            ch[i][1] = sc.nextLine().toCharArray();
            ch[i][2] = sc.nextLine().toCharArray();
        }
        int q = Integer.parseInt(sc.nextLine());
        for(int i = 0; i < q; i++){
            int u = sc.nextInt();
            for(int j = 0; j < n; j++){
                if(ch[u - 1][1][j] == '1')  cond[j] = '0';
                if(ch[u - 1][2][j] == '1')  cond[j] = '1';
            }
            int cnt = 0;
            for(int j = 0; j < n; j++){
                if(cond[j] == '1')  cnt++;
            }
            System.out.println(cnt);
        }
    }
}

135. 皇后移动的最小步数

题目描述

有一个 n 行 m 列的棋盘，有一些格子是障碍物不能通过。
小红控制一个皇后在从左上角出发，每次移动她可以控制皇后进行以下三种方式中的一种:
1.向右移动若干个格子。
2.向下移动若干个格子。
3.向右下移动若干个格子。
用数学语言描述，当前的坐标在 (x, y) 时，每次移动可以到 (x + k, y) 或 (x, y + k) 或 (x + k, y + k) 其中 k 为任意正整数。
移动的前提是，路径上没有障碍物。 
小红想知道，皇后从左上角移动到右下角，最少要移动多少步?

输入描述

第一行输入两个正整数 n 和 m（1 <= n,m <= 2000），代表行数和列数。 
接下来的 n 行，每行输入一个长度 m 的字符串，用来表示棋盘。
其中 "." 代表可以通过的位置，"*" 代表障碍物。 保证左上角和右下角都不是障碍物。

输出描述

如果无法到达，请输出-1。 
否则输出一个整数，代表最少的移动次数。

输入示例

4 5
...*.
*..**
.....
.....

输出示例

2

很显然的动态规划题， d p [ i ] [ j ] dp[i][j] dp[i][j]表示到第 i i i行第 j j j列需要的最小步数，需要注意表示不可达，所以就需要进行判断三个可能的方向。
rowMin表示从左边到达的最小值，当前位置不是’'时，每次循环会对其进行更新
colMin表示从上边到达的最小值

import java.util.*;
class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        char[][] ch = new char[m][n];
        for (int i = 0; i < m; i++) {
            ch[i] = sc.next()
                    .toCharArray();
        }
        System.out.println(solve(ch));
    }

    public static int solve(char[][] ch) {
        int m = ch.length;
        int n = ch[0].length;
        int[][] dp = new int[m][n];
        int[] rowMin = new int[m];
        int[] colMin = new int[n];
        Map<Integer, Integer> map = new HashMap<>();
        map.put(0, 0);
        int INF = Integer.MAX_VALUE;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                dp[i][j] = INF;
            }
        }
        for (int i = 1; i < m; i++) {
            rowMin[i] = INF;
        }
        for (int i = 1; i < n; i++) {
            colMin[i] = INF;
        }
        dp[0][0] = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0 && j == 0) {
                    continue;
                }
                if (ch[i][j] == '*') {
                    dp[i][j] = INF;
                    rowMin[i] = INF;
                    colMin[j] = INF;
                    map.put(j - i, INF);
                    continue;
                }
                if (rowMin[i] != INF) {
                    dp[i][j] = Math.min(dp[i][j], rowMin[i] + 1);
                }
                if (colMin[j] != INF) {
                    dp[i][j] = Math.min(dp[i][j], colMin[j] + 1);
                }
                if (map.getOrDefault(j - i, INF) != INF) {
                    dp[i][j] = Math.min(dp[i][j], map.get(j - i) + 1);
                }
                rowMin[i] = Math.min(rowMin[i], dp[i][j]);
                colMin[j] = Math.min(colMin[j], dp[i][j]);
                map.put(j - i, Math.min(map.getOrDefault(j - i, INF), dp[i][j]));
            }
        }
        return dp[m - 1][n - 1] == INF ? -1 : dp[m - 1][n - 1];
    }
}

144. 字典序最小的 01 字符串

题目描述

小红有一个 01 字符串，她可以进行最多 k 次提作，
每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。

输入描述

第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），
表示字符串的长度和可以进行的操作次数。
接下来一行一个长度为 n 的 01 字符串。

输出描述

输出一个长度为 n 的字符串，表示字典序最小的字符串。

输入示例

5 2
01010

输出示例

00101

思路：模拟

import java.util.*;
class Main{
    public static void main (String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        sc.nextLine();
        String s = sc.nextLine();
        char[] ch = s.toCharArray();
        int i = 0;
        for(; i< n;i++){
            while(i != 0 && ch[i] == '0' && ch[i-1] == '1'){
                ch[i] = '1';
                ch[i-1] = '0';
                k--;
                i--;
                if(k == 0){
                    System.out.println(String.valueOf(ch));
                    return;
                }
            }
        }
        System.out.println(String.valueOf(ch));
    }
}

145. 数组子序列的排列

题目描述

讨厌鬼有一个长度为 n （1 < n < 10^5）的数组，他想知道这个数组有多少个子序列是一个排列? 
子序列的定义: 数组删除若干个元素(也可以不删)后得到的新数组。 
排列的定义: 长度为 m 的数组，1 到 m 每个元素都出现过，且恰好出现 1 次。

输入描述

第一行输入一个整数 n。 
第二行输入 n 个正整数，a1, a2, ..., an。（1 <= ai <= 10^9）

输出描述

一行一个整数，表示有多少个子序列是一个排列。由于答案过大，请将答案对 10^ 9 + 7 取模后输出

输入示例

6
1 1 5 2 3 4

输出示例

10

提示信息

符合要求的子序列有：
{1}，{1}，{1，2}，{1，2}，{1，2，3}，{1，2，3}，{1，2，3，4}，{1，2，3，4}，{1，5，2，3，4}，{1，5，2，3，4}
共 10 个

排列的个数等于每个数字出现的个数的乘积，计算每个数个数字出现的乘积，然后再累加即可。

import java.util.*;
class Main{
    public static void main (String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr = new int[n];
        for(int i = 0; i < n; i++){
            arr[i] = sc.nextInt();
        }
        long MOD = 1000000007L;
        Map<Integer,Integer> map = new HashMap<>();
        for(int num : arr){
            map.put(num, map.getOrDefault(num, 0)+1);
        }
        long k = 1L;
        long res = 0L;
        for(int i = 1; i <=n; i++){
            if(!map.containsKey(i)){
                break;
            }
            k = (k * map.get(i)) % MOD;
            res = (res + k) % MOD;
        }
        System.out.println(res);
    }
}

146. 传送树

题目描述

小红有一棵传送树，树上有 n (1 <= n <= 10^5) 个节点，编号为 1 到 n，其中 1 号节点为根节点。 
每个节点都有一个传送门，传送门只可以将小红传送到子树中除了自己的其他节点中编号最小的节点。 
小红想知道，经过若干次传送门直到叶子节点为止，可以到达的节点数量是多少。

输入描述

一行一个整数 n，表示树上的节点数量接下来 n - 1 行，每行两个整数 u, v，
表示 u 号节点和 v 号节点之间有一条边（u 指向 v）。

输出描述

输出一行，n 个整数，分别对树上 n 个节点都需要计算答案，
第 i 数字表示小红从第 i 个节点出发，经过若干次传送门到达叶子节点为止，可以到达的节点数量是多少。

输入示例

5
1 4
4 2
4 3
3 5

输出示例

2 1 2 2 1

构造有向图的领接表，然后利用dfs求解，每次选择编号最小的叶子结点+1，返回时也是将最小编号返回（需要和当前start进行比较）

import java.util.*;
public class Main {
    static int[] res;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        res = new int[n + 1];
        List<Integer>[] list = new List[n + 1];
        for(int i = 1; i <= n; i++){
            list[i] = new ArrayList<>();
        }
        for(int i = 1; i < n; i++){
            int u = sc.nextInt();
            int v = sc.nextInt();
            list[u].add(v);
        }
        dfs(list, 1);
        for(int i = 1; i <= n; i++){
            System.out.print(res[i]+" ");
        }
    }
    public static int dfs(List<Integer>[] list, int start){
        if(list[start].size() == 0){
            res[start] = 1;
            return start;
        }
        int min = Integer.MAX_VALUE;
        for(int num : list[start]){
            min = Math.min(min, dfs(list, num));
        }
        res[start] = res[min] + 1;
        return Math.min(start, min);
    }
}
＆u204
关注
  • 16
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
卡码网京东模拟笔试（2023京东真题）
TIANBIU的博客
06-21 230
已知共有 n 种症状和 m 种药，第 i 种药可以治疗一些症状，但可能会导致一些副作用，添加一些新的症状。小红依次服用了一些药，请你告诉小红，当她每次服用一副药时，当前还有多少症状？所谓“夹吃棋”，即如果存在一个白子，它的两侧 (横向或者纵向)相邻都是黑子，则这个棋子将被“夹吃”，对于黑棋亦然。如果一个棋盘的局面没有一方被夹吃，或者黑白双方都被对面夹吃，则认为是平局。如果只有一方夹吃了另一方，则认为夹吃方赢，被夹吃方输。小红执黑棋，小紫执白棋，现在给定一个局面，请你判断当前棋局是谁获胜。
LightOJ 1061 N Queen Again（搜索+状压DP）
KIJamesQi的博客
02-17 580
题目 给出一张8*8的图，上面有8个皇后，现在每次只能移动一个皇后往同一个方向走任意步，总共有8个方向；问最少需要多少步使得所有皇后相互不会攻击对方？ 思路 单纯的暴搜是不行的，时空都会炸。 假如我们知道最终每个皇后应该在的位置，然后再来计算最少步数就会简单不少，这里可以用状压来做； 因为最终的情况是每行有一个皇后，所以我没需要记录每行皇后所在的列，然后枚举哪个皇后移动到这个位置
算法及题目详解整合
出门左拐是海的博客
11-04 90
本文作为一个大纲，将之后将要增补的算法总结和题目详解文章及其群类整理出一个大概的列表。并在之后的每篇文章中以算法理念，模板，例题，应用题目类型进行整理。 1.搜索 深度优先搜索（DFS） 广度优先搜索（BFS） 2.二叉树 普通二叉树 查找二叉树 平衡二叉树 并查集 堆 3.图 最短路径 最小生成树 拓扑排序 关键路径 4.动态规划 最长连续子序列和 最长不下降子序列（LIS） 最长公共子序列（LCS） 最长回文子串 DAG最长路 背包问题 ...
备战蓝桥杯算法整合
Anterior_condyle的博客
09-25 2518
这里写目录标题六倍法判断素数欧拉筛01背包完全背包多重度背包Floyd-Warshall（多源最短路）Dijkstra(单源最短路)最大公约数最小公倍数分解质因数全排列（递归）并查集 六倍法判断素数 bool is_sprime(int x){ if(x==1)return false;//1不是素数 if(x==2||x==3||x==5){//2,3,5是素数 return true; } if(x%2==0||x%3==0){//2和3的倍数一定不是素数 return false
北大郭炜算法课笔记整合
amzirl的博客
06-06 473
中国MOOC北大郭炜算法课笔记整理
leetcode背诵+算法知识整合1
08-08
本篇文章将针对标题"leetcode背诵+算法知识整合1"和描述中的内容，深入探讨一系列与动态规划和树形结构相关的LeetCode题目，以及它们所涵盖的关键知识点。 首先，动态规划是一种解决复杂问题的有效方法，它通过将大...
机器学习算法，大厂面经，coding，算法比赛资源整合
05-07
机器学习算法，大厂面经，coding，算法比赛资源整合大礼包～助你校招乘风破浪！ 机器学习算法、大厂面经、coding和算法比赛这四个主题都与计算机科学、软件开发和算法设计密切相关。下面我将分别简要介绍它们： ...
算法工程师面试问题1
08-03
以下是针对题目中提到的知识点的详细解释： 1. **后续优化**：在深度学习项目中，优化通常包括调整超参数、使用更复杂的网络架构、集成学习、正则化策略（如Dropout或L1/L2正则化）、数据增强、早停法以及迁移学习...
广工算法设计与分析
05-04
对于准备广工《算法分析与设计》课程考试的学生来说，除了理解上述知识点，还需要通过做历年试题进行实践，理解题目的出题思路和解题技巧。通过模拟考试环境，熟悉考试的格式和时间压力，可以有效提高应对考试的能力...
基于matlab实现遗传算法无功优化，基于掌纹识别的在线身份验证 识别算法本科毕设，是本科毕设的题目 .rar
05-04
为了完成整个毕设，学生还需要对电力系统无功优化有深入理解，并掌握掌纹识别的基本流程和技术，以及如何在MATLAB环境中整合这两个部分，形成一个完整的解决方案。 总的来说，这个项目既考察了学生的编程能力，也...
【18】输出字符菱形
2301_78786609的博客
07-19 382
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 325
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
算法题目整合5
qq_62571233的博客
07-23 626
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 123
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
2024.7.19 刷题总结
TheJustice_的博客
07-19 248
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
3.5 查找和排序算法
m0_38066007的博客
07-23 73
大纲 算法基础 常用的表示算法的方法 算法的复杂度 查找 顺序查找、二分查找 哈希查找 真题 排序 插入排序 希尔排序 简单选择排序 堆排序 冒泡排序
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 267
完全二叉树的节点个数-递归
python实现图像缩放算法
qq_42568323的博客
07-20 338
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
AtCoder Beginner Contest 363(A~D题)
最新发布
sin1810335764的博客
07-23 116
枚举长度，首先计算出答案回文数的长度。通过枚举和减法可以计算出是当前长度下第k𝑘大的回文数。而前一半就是顺序的，第k𝑘大就是当前长度的数的第k𝑘大，这个很好求。接下来只需要构成回文，直接输出即可。将L𝐿从小往大排序，那么只需要第n−P+1𝑛−𝑃+1大的数满足条件即可，假设这个数是a𝑎。因此，只需要计算T−a𝑇−𝑎即可。注意，如果这个数是负数，意味着初始时就满足条件，此时要输出00。我们只需要找到下一阶段的下限。a / 100 是本阶段+1 变成下一阶段，再 * 100变成下限，再与原来的相减即可。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值