题目

• 给定两个整数数组，从两个数组中各取一个元素，要求它们的差值绝对值最小

代码

1. 先排序，后双指针

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = {1, 3, 5, 11};
        int[] arr2 = {4, 7, 9};

        Arrays.sort(arr1);
        Arrays.sort(arr2);

        int i = 0, j = 0;
        int minDiff = Integer.MAX_VALUE;
        int num1 = -1, num2 = -1;

        while (i < arr1.length && j < arr2.length) {
            int diff = Math.abs(arr1[i] - arr2[j]);
            if (diff < minDiff) {
                minDiff = diff;
                num1 = arr1[i];
                num2 = arr2[j];
            }
            // 如果不需要记录两个数分别是多少，可以直接使用以下语句
            // minDiff = Math.min(minDiff, Math.abs(arr1[i] - arr2[j]));

            if (arr1[i] < arr2[j]) {
                i++;
            } else {
                j++;
            }
        }

        System.out.println("两个数组中差值绝对值最小的元素是 " + num1 + " 和 " + num2);
        System.out.println("它们的差值绝对值是 " + minDiff);

    }
}

题目

• 给定一个不含重复数字的数组 nums ，返回其所有可能的全排列 。

代码

1. 非递归实现，借助栈

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * @author: Li Qiang
 * @date: 2023/7/26
 * @description: 全排列问题的非递归实现
 */
public class Permutations {
    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] nums = {1, 2, 3, 4};
        List<List<Integer>> permutations = solution.permute(nums);
        // 输出验证
        for (List<Integer> permutation : permutations) {
            System.out.println(permutation);
        }
    }
}
class Solution {
    public List<List<Integer>> permute(int[] nums) {
        int n = nums.length;
        // 定义结果列表
        List<List<Integer>> ans = new ArrayList<>();
        // 借助栈模拟递归过程
        Stack<List<Integer>> stack = new Stack<>();
        stack.push(new ArrayList<>());

        while (!stack.isEmpty()) {
            // currentPath代表当前的排列（不一定是全排列）
            // 其中的元素代表已将被当前排列采用的元素
            List<Integer> currentPath = stack.pop();
            if (currentPath.size() == n) {
                // 如果当前的排列是全排列，将其添加到结果列表中
                ans.add(currentPath);
            } else {
                // 如果当前的排列没有完成，通过添加未使用的元素来补充它
                for (int element : nums) {
                    if (!currentPath.contains(element)) {
                        // 如果当前排列的元素中不包含element，则采纳当前数组元素并将其放进新排列中
                        List<Integer> newPath = new ArrayList<>(currentPath);
                        newPath.add(element);
                        // 新的排列（不一定是全排列）暂时压入栈中
                        stack.push(newPath);
                    }
                }
            }
        }
        return ans;
    }
}

2. 递归实现

/**
 * @author: Li Qiang
 * @date: 2023/7/26
 * @description: 全排列问题的递归实现
 */
class Solution {
    List<List<Integer>> ans;
    boolean[] visited;
    List<Integer> path;
    public List<List<Integer>> permute(int[] nums) {
        int n = nums.length;
        ans = new ArrayList<>();
        visited = new boolean[n];
        path = new ArrayList<>();
        
        loop(nums, 0, n);
        return ans;

    }
    public void loop(int[] nums, int len, int n) {
        if (len == n) {
            ans.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < n; i ++) {
            if (visited[i] == true) {
                continue;
            } else {
                visited[i] = true;
                path.add(nums[i]);
                loop(nums, len + 1, n);
                // 回溯
                path.remove(path.size() - 1);
                visited[i] = false;
            }
        }

    }
}

SpringBoot项目，使用OSHI获取系统状态信息时，后端打印正常，返回至前端的过程中遇到了以下两个报错

1. java.lang.IllegalStateException: Unmapped relationship: 7
2. COM exception querying MSAcpi_ThermalZoneTemperature, which might not be on

解决方式如下：

题目

• 创建三个线程，按指定顺序打印1到100，具体如下：

  • 线程1打印1
  • 线程2打印2
  • 线程3打印3
  • 线程1打印4
  • 线程2打印5
  • 线程3打印6
  • ……
  • 线程3打印99
  • 线程1打印100

• 知识点：wait()/notifyAll()

代码

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author: LiQiang
 * @date: 2023/03/30
 * @description: 三个线程按顺序打印1到100
 */
public class Main {
    // 锁
    private static Object resource = new Object();
    // 打印区分标识(值为1~3，初始设置1)
    private static int flag = 1;
    // 需要打印的值
    static AtomicInteger integer = new AtomicInteger(1);
    // private static volatile int number = 1;

    public static void main(String[] args) {
        // 三个线程按顺序打印1~100
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (integer.get() <= 100) {
                    synchronized (resource) {
                        while (flag != 1) {
                            try {
                                resource.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        // 打印操作
                        if (integer.get() <= 100) {
                            System.out.println(Thread.currentThread().getName() + " --- " + integer.getAndIncrement());
                        } else {
                            Thread.currentThread().interrupt();
                            // break;
                        }
                        // number ++;
                        // 变更标识
                        flag = 2;
                        // 通知线程2
                        resource.notifyAll();
                    }
                }
            }
        }, "线程1").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (integer.get() <= 100) {
                    synchronized (resource) {
                        while (flag != 2) {
                            try {
                                resource.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        // 打印操作
                        if (integer.get() <= 100) {
                            System.out.println(Thread.currentThread().getName() + " --- " + integer.getAndIncrement());
                        } else {
                            Thread.currentThread().interrupt();
                            // break;
                        }
                        // 变更标识
                        flag = 3;
                        // 通知线程3
                        resource.notifyAll();
                    }
                }
            }
        }, "线程2").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (integer.get() <= 100) {
                    synchronized (resource) {
                        while (flag != 3) {
                            try {
                                resource.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        // 打印操作
                        if (integer.get() <= 100) {
                            System.out.println(Thread.currentThread().getName() + " --- " + integer.getAndIncrement());
                        } else {
                            Thread.currentThread().interrupt();
                            // break;
                        }
                        // 变更标识
                        flag = 1;
                        // 通知线程1
                        resource.notifyAll();
                    }
                }
            }
        }, "线程3").start();
    }
}

需求

从指定网站中获取不同分类下的所有国自然项目数据，如优青、杰青、面上、重大等分类中的项目数据。

依赖包

• urllib3
• time
• csv

代码

整个过程分为数据获取和数据处理两部分，具体代码如下。

执行命令 pip uninstall scikit-learn 报错，Cannot uninstall ‘scikit-learn’

具体报错如下：

ERROR: Cannot uninstall 'scikit-learn'. It is a distutils installed project and thus we cannot accurately determine which files belong to it which would lead to only a partial uninstall.

不能卸载“scikit-learn”。这是一个安装了distutils的项目，因此我们不能准确地确定哪些文件属于它，这将导致只有部分卸载。

原文：Kalisch M, Buehlmann P. Estimating high-dimensional directed acyclic graphs with the PC-algorithm. J Mach Learn Res 2007;8:613–36.
原文网页版
Web of science

Abstract

本文研究了PC算法用于估计具有相应高斯分布的高维有向无环图（DAG）的骨架和等价类。 对于有许多节点（变量）的稀疏问题，PC算法在计算上是可行的，而且往往非常快，它具有吸引人的特性，可以自动实现高计算效率，作为真实底层DAG的稀疏程度的函数。本文证明了该算法在高维稀疏DAGs中的一致性，并允许节点数量随样本大小n快速增长，对于任何0 < a <∞快如$O(n^a)$。稀疏性假设是相当最小的，只要求DAG中的邻域的阶数低于样本容量n。文章还演示了模拟数据的PC算法。

题目描述

• 给定一个长度为 n 的整数数组 height 。
• 有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
• 找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
• 返回容器可以储存的最大水量。
• 说明：不能倾斜容器。

example
input  : [1,8,6,2,5,4,8,3,7]
output : 49

input  : [1,1]
output : 1

input  : [4, 4, 2, 11, 0, 11, 5, 11, 13, 8]
output : 55

题目描述

• 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
• 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
• 问总共有多少条不同的路径？

example
input  : m = 3, n = 2
output : 3
note   : 从左上角开始，总共有 3 条路径可以到达右下角。
         1. 向右 -> 向下 -> 向下
         2. 向下 -> 向下 -> 向右
         3. 向下 -> 向右 -> 向下

input  : m = 7, n = 3
output : 28

问题：

• 本地项目push到github失败

  Push failed
  Kex_exchange_identification: Connection closed by remote hostConnection closed by 20.205.243.166 port 22
  Could not read from remote repository.
  Please make sure you have the correct access rightsand the repository exists.

• 同样地，从github中clone、pull、fetch也报上述错误