矩阵连乘 动态规划_Java动态规划

1. 介绍

动态规划典型的被用于优化递归算法，因为它们倾向于以指数的方式进行扩展。动态规划主要思想是将复杂问题(带有许多递归调用)分解为更小的子问题，然后将它们保存到内存中，这样我们就不必在每次使用它们时重新计算它们。

要理解动态规划的概念，我们需要熟悉一些主题：

  1. 什么是动态规划？
  2. 贪心算法
  3. 简化的背包问题
  4. 传统的背包问题
  5. Levenshtein Distance
  6. LCS-最长的共同子序列
  7. 利用动态规划的其他问题
  8. 结论

本文所有代码均为java代码实现。

2. 什么是动态规划？

动态规划是一种编程原理，可以通过将非常复杂的问题划分为更小的子问题来解决。这个原则与递归很类似，但是与递归有一个关键点的不同，就是每个不同的子问题只能被解决一次。

为了理解动态规划，我们首先需要理解递归关系的问题。每个单独的复杂问题可以被划分为很小的子问题，这表示我们可以在这些问题之间构造一个递归关系。

让我们来看一个我们所熟悉的例子：斐波拉契数列，斐波拉契数列的定义具有以下的递归关系：

9797868a7ab6b237e12658cfca1c2ad7.png

注意：递归关系是递归地定义下一项是先前项的函数的序列的等式。Fibonacci序列就是一个很好的例子。

所以，如果我们想要找到斐波拉契数列序列中的第n个数，我们必须知道序列中第n个前面的两个数字。

但是，每次我们想要计算Fibonacci序列的不同元素时，我们在递归调用中都有一些重复调用，如下图所示，我们计算Fibonacci(5)：

428809edddfea2a7cff0a3159cf9a890.png

例如：如果我们想计算F(5),明显的我们需要计算F(3)和F(4)作为计算F(5)的先决条件。然而，为了计算F(4)，我们需要计算F(3)和F(2)，因此我们又需要计算F(2)和F(1)来得到F(3)，其他的求解诸如此类。

这样的话就会导致很多重复的计算，这些重复计算本质上是冗余的，并且明显的减慢了算法的效率。为了解决这种问题，我们介绍动态规划。

在这种方法中，我们对解决方案进行建模，就像我们要递归地解决它一样，但我们从头开始解决它，记忆到达顶部采取的子问题(子步骤)的解决方案。

因此，对于Fibonacci序列，我们首先求解并记忆F(1)和F(2)，然后使用两个记忆步骤计算F(3)，依此类推。这意味着序列中每个单独元素的计算都是O(1)，因为我们已经知道前两个元素。

当使用动态规划解决问题的时候，我们一般会采用下面三个步骤：

  1. 确定适用于所述问题的递归关系
  2. 初始化内存、数组、矩阵的初始值
  3. 确保当我们进行递归调用(可以访问子问题的答案)的时候它总是被提前解决。

遵循这些规则，让我们来看一下使用动态规划的算法的例子：

3. 贪心算法

下面来以这个为例子：

Given a rod of length n and an array that contains prices of all pieces of size smaller than n. Determine the maximum value obtainable by cutting up the rod and selling the pieces.

3.1. 对于没有经验的开发者可能会采取下面这种做法

这个问题实际上是为动态规划量身定做的，但是因为这是我们的第一个真实例子，让我们看看运行这些代码会遇到多少问题：

public class naiveSolution {  static int getValue(int[] values, int length) { if (length <= 0) return 0; int tmpMax = -1; for (int i = 0; i < length; i++) { tmpMax = Math.max(tmpMax, values[i] + getValue(values, length - i - 1)); } return tmpMax; } public static void main(String[] args) { int[] values = new int[]{3, 7, 1, 3, 9}; int rodLength = values.length; System.out.println("Max rod value: " + getValue(values, rodLength)); }}

输出结果：

Max rod value: 17

该解决方案虽然正确，但效率非常低，递归调用的结果没有保存，所以每次有重叠解决方案时，糟糕的代码不得不去解决相同的子问题。

3.2.动态方法

利用上面相同的基本原理，添加记忆化并排除递归调用，我们得到以下实现:

public class dpSolution {  static int getValue(int[] values, int rodLength) { int[] subSolutions = new int[rodLength + 1]; for (int i = 1; i <= rodLength; i++) { int tmpMax = -1; for (int j = 0; j < i; j++) tmpMax = Math.max(tmpMax, values[j] + subSolutions[i - j - 1]); subSolutions[i] = tmpMax; } return subSolutions[rodLength]; } public static void main(String[] args) { int[] values = new int[]{3, 7, 1, 3, 9}; int rodLength = values.length; System.out.println("Max rod value: " + getValue(values, rodLength)); }}

输出结果：

Max rod value: 17

正如我们所看到的的，输出结果是一样的，所不同的是时间和空间复杂度。

通过从头开始解决子问题，我们消除了递归调用的需要，利用已解决给定问题的所有先前子问题的事实。

性能的提升

为了给出动态方法效率更高的观点的证据，让我们尝试使用30个值来运行该算法。 一种算法需要大约5.2秒来执行，而动态解决方法需要大约0.000095秒来执行。

4. 简化的背包问题

简化的背包问题是一个优化问题，没有一个解决方案。这个问题的问题是 - “解决方案是否存在？”：

Given a set of items, each with a weight w1, w2... determine the number of each item to put in a knapsack so that the total weight is less than or equal to a given limit K.

给定一组物品，每个物品的重量为w1，w2 …确定放入背包中的每个物品的数量，以使总重量小于或等于给定的极限K

首先让我们把元素的所有权重存储在W数组中。接下来，假设有n个项目，我们将使用从1到n的数字枚举它们，因此第i个项目的权重为W [i]。我们将形成(n + 1)x(K + 1)维的矩阵M。M [x] [y]对应于背包问题的解决方案，但仅包括起始数组的前x个项，并且最大容量为y

例如

假设我们有3个元素，权重分别是w1=2kg,w2=3kg,w3=4kg。利用上面的方法，我们可以说M [1] [2]是一个有效的解决方案。

这意味着我们正在尝试用重量阵列中的第一个项目(w1)填充容量为2kg的背包。

在M [3] [5]中，我们尝试使用重量阵列的前3项(w1，w2，w3)填充容量为5kg的背包。

这不是一个有效的解决方案，因为我们过度拟合它。

4.1. 矩阵初始化

当初始化矩阵的时候有两点需要注意：

Does a solution exist for the given subproblem (M[x][y].exists) AND does the given solution include the latest item added to the array (M[x][y].includes).

给定子问题是否存在解(M [x] [y] .exists)并且给定解包括添加到数组的最新项(M [x] [y] .includes)。

因此，初始化矩阵是相当容易的，M[0][k].exists总是false，如果k>0，因为我们没有把任何物品放在带有k容量的背包里。

另一方面，M[0][0].exists = true,当k=0的时候，背包应该是空的，因此我们在里面没有放任何东西，这个是一个有效的解决方案。

此外，我们可以说M[k][0].exists = true，但是对于每个k来说 M[k][0].includes = false。

注意：仅仅因为对于给定的M [x] [y]存在解决方案，它并不一定意味着该特定组合是解决方案。

在M [10] [0]的情况下，存在一种解决方案 - 不包括10个元素中的任何一个。

这就是M [10] [0] .exists = true但M [10] [0] .includes = false的原因。

4.2.算法原则

接下来，让我们使用以下伪代码构造M [i] [k]的递归关系：

if (M[i-1][k].exists == True):  M[i][k].exists = True M[i][k].includes = Falseelif (k-W[i]>=0):  if(M[i-1][k-W[i]].exists == true): M[i][k].exists = True M[i][k].includes = Trueelse:  M[i][k].exists = False

因此，解决方案的要点是将子问题分为两种情况:

  1. 对于容量k,当存在第一个i-1元素的解决方案
  2. 对于容量k-W [i],当第一个i-1元素存在解决方案

第一种情况是不言自明的，我们已经有了问题的解决方案。

第二种情况是指了解第一个i-1元素的解决方案，但是容量只有一个第i个元素不满，这意味着我们可以添加一个第i个元素，并且我们有一个新的解决方案！

4.3. 实现

下面这何种实现方式，使得事情变得更加容易，我们创建了一个类Element来存储元素：

public class Element {  private boolean exists; private boolean includes; public Element(boolean exists, boolean includes) { this.exists = exists; this.includes = includes; } public Element(boolean exists) { this.exists = exists; this.includes = false; } public boolean isExists() { return exists; } public void setExists(boolean exists) { this.exists = exists; } public boolean isIncludes() { return includes; } public void setIncludes(boolean includes) { this.includes = includes; }}

接着，我们可以深入了解主要的类：

public class Knapsack {  public static void main(String[] args) { Scanner scanner = new Scanner (System.in); System.out.println("Insert knapsack capacity:"); int k = scanner.nextInt(); System.out.println("Insert number of items:"); int n = scanner.nextInt(); System.out.println("Insert weights: "); int[] weights = new int[n + 1]; for (int i = 1; i <= n; i++) { weights[i] = scanner.nextInt(); } Element[][] elementMatrix = new Element[n + 1][k + 1]; elementMatrix[0][0] = new Element(true); for (int i = 1; i <= k; i++) { elementMatrix[0][i] = new Element(false); } for (int i = 1; i <= n; i++) { for (int j = 0; j <= k; j++) { elementMatrix[i][j] = new Element(false); if (elementMatrix[i - 1][j].isExists()) { elementMatrix[i][j].setExists(true); elementMatrix[i][j].setIncludes(false); } else if (j >= weights[i]) { if (elementMatrix[i - 1][j - weights[i]].isExists()) { elementMatrix[i][j].setExists(true); elementMatrix[i][j].setIncludes(true); } } } } System.out.println(elementMatrix[n][k].isExists()); }}

唯一剩下的就是解决方案的重建，在上面的类中，我们知道解决方案是存在的，但是我们不知道它是什么。

为了重建，我们使用下面的代码：

List solution = new ArrayList<>(n);if (elementMatrix[n][k].isExists()) {  int i = n; int j = k; while (j > 0 && i > 0) { if (elementMatrix[i][j].isIncludes()) { solution.add(i); j = j - weights[i]; } i = i - 1; }}System.out.println("The elements with the following indexes are in the solution:" + (solution.toString()));

输出：

Insert knapsack capacity: 12 Insert number of items: 5 Insert weights: 9 7 4 10 3 true The elements with the following indexes are in the solution: [5, 1]

背包问题的一个简单变化是在没有价值优化的情况下填充背包，但现在每个单独项目的数量无限。

通过对现有代码进行简单调整，可以解决这种变化：

// Old code for simplified knapsack problemelse if (j >= weights[i]) {  if (elementMatrix[i - 1][j - weights[i]].isExists()) { elementMatrix[i][j].setExists(true); elementMatrix[i][j].setIncludes(true); }}// New code, note that we're searching for a solution in the same// row (i-th row), which means we're looking for a solution that// already has some number of i-th elements (including 0) in it's solutionelse if (j >= weights[i]) {  if (elementMatrix[i][j - weights[i]].isExists()) { elementMatrix[i][j].setExists(true); elementMatrix[i][j].setIncludes(true); }}

5. 传统的背包问题

利用以前的两种变体，现在让我们来看看传统的背包问题，看看它与简化版本的不同之处：

Given a set of items, each with a weight w1, w2... and a value v1, v2... determine the number of each item to include in a collection so that the total weight is less than or equal to a given limit k and the total value is as large as possible.

在简化版中，每个解决方案都同样出色。但是，现在我们有一个找到最佳解决方案的标准(也就是可能的最大值)。请记住，这次我们每个项目都有无限数量，因此项目可以在解决方案中多次出现。

在实现中，我们将使用旧的类Element，其中添加了私有字段value，用于存储给定子问题的最大可能值:

public class Element {  private boolean exists; private boolean includes; private int value; // appropriate constructors, getters and setters}

实现非常相似，唯一的区别是现在我们必须根据结果值选择最佳解决方案：

public static void main(String[] args) {  // Same code as before with the addition of the values[] array System.out.println("Insert values: "); int[] values = new int[n + 1]; for (int i=1; i <= n; i++) { values[i] = scanner.nextInt(); } Element[][] elementMatrix = new Element[n + 1][k + 1]; // A matrix that indicates how many newest objects are used // in the optimal solution. // Example: contains[5][10] indicates how many objects with // the weight of W[5] are contained in the optimal solution // for a knapsack of capacity K=10 int[][] contains = new int[n + 1][k + 1]; elementMatrix[0][0] = new Element(0); for (int i = 1; i <= n; i++) { elementMatrix[i][0] = new Element(0); contains[i][0] = 0; } for (int i = 1; i <= k; i++) { elementMatrix[0][i] = new Element(0); contains[0][i] = 0; } for (int i = 1; i <= n; i++) { for (int j = 0; j <= k; j++) { elementMatrix[i][j] = new Element(elementMatrix[i - 1][j].getValue()); contains[i][j] = 0; elementMatrix[i][j].setIncludes(false); elementMatrix[i][j].setValue(M[i - 1][j].getValue()); if (j >= weights[i]) { if ((elementMatrix[i][j - weights[i]].getValue() > 0 || j == weights[i])) { if (elementMatrix[i][j - weights[i]].getValue() + values[i] > M[i][j].getValue()) { elementMatrix[i][j].setIncludes(true); elementMatrix[i][j].setValue(M[i][j - weights[i]].getValue() + values[i]); contains[i][j] = contains[i][j - weights[i]] + 1; } } } System.out.print(elementMatrix[i][j].getValue() + "/" + contains[i][j] + " "); } System.out.println(); } System.out.println("Value: " + elementMatrix[n][k].getValue());}

输出：

Insert knapsack capacity: 12 Insert number of items: 5 Insert weights: 9 7 4 10 3 Insert values: 1 2 3 4 5 0/0 0/0 0/0 0/0 0/0 0/0 0/0 0/0 0/0 1/1 0/0 0/0 0/0 0/0 0/0 0/0 0/0 0/0 0/0 0/0 2/1 0/0 1/0 0/0 0/0 0/0 0/0 0/0 0/0 0/0 3/1 0/0 0/0 2/0 6/2 1/0 0/0 5/1 9/3 0/0 0/0 0/0 0/0 3/0 0/0 0/0 2/0 6/0 1/0 4/1 5/0 9/0 0/0 0/0 0/0 5/1 3/0 0/0 10/2 8/1 6/0 15/3 13/2 11/1 20/4 Value: 20

6. Levenshtein Distance

另一个使用动态规划的非常好的例子是Edit Distance或Levenshtein Distance。

Levenshtein Distance就是两个字符串A,B,我们需要使用原子操作将A转换为B：

  1. 字符串删除
  2. 字符串插入
  3. 字符替换(从技术上讲，它不止一个操作，但为了简单起见，我们称之为原子操作)

这个问题是通过有条理地解决起始字符串的子串的问题来处理的，逐渐增加子字符串的大小，直到它们等于起始字符串。

我们用于此问题的递归关系如下：

a9b049e29891b6373d116e7e28e6dac7.png

如果a == b则c(a，b)为0，如果a = = b则c(a，b)为1。

实现：

public class editDistance {  public static void main(String[] args) { String s1, s2; Scanner scanner = new Scanner(System.in); System.out.println("Insert first string:"); s1 = scanner.next(); System.out.println("Insert second string:"); s2 = scanner.next(); int n, m; n = s1.length(); m = s2.length(); // Matrix of substring edit distances // example: distance[a][b] is the edit distance // of the first a letters of s1 and b letters of s2 int[][] distance = new int[n + 1][m + 1]; // Matrix initialization: // If we want to turn any string into an empty string // the fastest way no doubt is to just delete // every letter individually. // The same principle applies if we have to turn an empty string // into a non empty string, we just add appropriate letters // until the strings are equal. for (int i = 0; i <= n; i++) { distance[i][0] = i; } for (int j = 0; j <= n; j++) { distance[0][j] = j; } // Variables for storing potential values of current edit distance int e1, e2, e3, min; for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { e1 = distance[i - 1][j] + 1; e2 = distance[i][j - 1] + 1; if (s1.charAt(i - 1) == s2.charAt(j - 1)) { e3 = distance[i - 1][j - 1]; } else { e3 = distance[i - 1][j - 1] + 1; } min = Math.min(e1, e2); min = Math.min(min, e3); distance[i][j] = min; } } System.out.println("Edit distance of s1 and s2 is: " + distance[n][m]); }}

输出：

Insert first string: man Insert second string: machine Edit distance of s1 and s2 is: 3

如果你想了解更多关于Levenshtein Distance的解决方案，我们在另外的一篇文章中用python实现了 Levenshtein Distance and Text Similarity in Python，

使用这个逻辑，我们可以将许多字符串比较算法归结为简单的递归关系，它使用Levenshtein Distance的基本公式

7. 最长共同子序列(LCS)

这个问题描述如下：

Given two sequences, find the length of the longest subsequence present in both of them. A subsequence is a sequence that appears in the same relative order, but not necessarily contiguous.

给定两个序列，找到两个序列中存在的最长子序列的长度。子序列是以相同的相对顺序出现的序列，但不一定是连续的.

阐明：

如果我们有两个字符串s1="MICE"和s2="MINCE

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/346345.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

c php乱码,php分割GBK中文乱码的解决方法

c php乱码,php分割GBK中文乱码的解决方法

类似如下的字符串(GBK), explode不能得到正确结果:$result explode("|", "滕华弢|海青");究其原因, 对于”弢”字(读tao,不认识没关系,我也不认识), 因为他的GBK编码值为: 8f7c, 不巧的是, “|”的ASCII值也是7c.还有一些类似的问题: 因为GBK编码的编码范…
阅读更多...
分布式光伏补贴_光伏发电上网电价政策综述

分布式光伏补贴_光伏发电上网电价政策综述

原标题&#xff1a;光伏发电上网电价政策综述近些年&#xff0c;光伏发电上网电价相关政策不断推陈出新&#xff0c;在推进平价上网的同时&#xff0c;也积极对接了电力市场建设需要。本文梳理了光伏发电上网电价及补贴标准有关政策&#xff0c;供参考使用&#xff1a;1.普通光…
阅读更多...
怎么简单的锁定文件夹_简单性与鲁棒性–在锁定文件处理中展示

怎么简单的锁定文件夹_简单性与鲁棒性–在锁定文件处理中展示

怎么简单的锁定文件夹今天&#xff0c;我们将讨论使事情保持简单&#xff0c;愚蠢&#xff08;KISS&#xff09;和鲁棒性的设计价值之间&#xff0c;设计不足和过度设计之间的冲突。 我们正在编写一个批处理Java应用程序&#xff0c;需要确保在服务器上一次最多运行一个实例。…
阅读更多...
php strlen 线程安全,浅析PHP中strlen和mb_strlen的区别

php strlen 线程安全,浅析PHP中strlen和mb_strlen的区别

在PHP中&#xff0c;strlen与mb_strlen是求字符串长度的函数&#xff0c;但是对于一些初学者来说&#xff0c;如果不看手册&#xff0c;也许不太清楚其中的区别。下面通过例子&#xff0c;讲解这两者之间的区别。先看例子&#xff1a;//测试时文件的编码方式要是UTF8$str中文a字…
阅读更多...
单片机float数发给上位机_上位机倒计时器

单片机float数发给上位机_上位机倒计时器

1. 设置窗口在VS2019新建一个Windows窗体应用(.NET Framework)项目&#xff0c;新建之后出现一个可视化页面(From1.cs[设计])设置窗口。在左侧的工具箱里面拉拽控件到操作面板上&#xff0c;按照自己的喜好摆放位置和调大小。这里要注意的是用到的分别是什么控件&#xff1a;文…
阅读更多...
JDK语言功能预览：切换表达式

JDK语言功能预览：切换表达式

JEP 12 [“预览语言和VM功能”]在其主页上描述如下&#xff1a; 预览语言或VM功能是Java SE平台的一项新功能&#xff0c;该功能已完全指定&#xff0c;完全实现但不是永久性的。 JDK功能发布中提供了该功能&#xff0c;以根据实际使用情况激发开发人员反馈。 这可能会导致它在…
阅读更多...
python快速示例_Python编程入门-基本示例,快速,上,手,基础

python快速示例_Python编程入门-基本示例,快速,上,手,基础

环境配置安装Python&#xff0c;目前最新的是3.9(不支持Windows7)&#xff0c;我装的3.7https://www.python.org/downloads/安装向导里勾选自动添加路径&#xff0c;装完就可以用&#xff0c;Windows10/7搜索框输入IDLE&#xff0c;进入交互式环境窗口&#xff0c;输入语句后&a…
阅读更多...
php 距离排序,php 附近由近到远排序查询

php 距离排序,php 附近由近到远排序查询

该楼层疑似违规已被系统折叠 隐藏此楼查看此楼//获取经纬度 默认值为0.5千米function returnSquarePoint($lng, $lat, $distance 0.5){define(EARTH_RADIUS, 6371); //地球半径&#xff0c;平均半径为6371km$dlng 2 * asin(sin($distance / (2 * EARTH_RADIUS)) / cos(deg2ra…
阅读更多...
土地利用覆被变化的概念_欠压实概念极其荒谬

土地利用覆被变化的概念_欠压实概念极其荒谬

●李传亮地表疏松的沉积物&#xff0c;孔隙度极高&#xff0c;有时可高达80%以上&#xff0c;但随着埋藏深度的加大&#xff0c;在上覆压力的作用下&#xff0c;其排列方式不断由松散排列趋于致密排列&#xff0c;同时伴随有孔隙度的大幅度减小&#xff0c;此即岩石的压实阶段&…
阅读更多...
java方法带参数返回值_Java方法中的参数太多，第6部分：方法返回

java方法带参数返回值_Java方法中的参数太多，第6部分：方法返回

java方法带参数返回值在当前的系列文章中&#xff0c;我正在致力于减少调用Java方法和构造函数所需的参数数量&#xff0c;到目前为止&#xff0c;我一直专注于直接影响参数本身的方法&#xff08; 自定义类型 &#xff0c; 参数对象 &#xff0c; 构建器模式 &#xff0c; 方法…
阅读更多...
java足球游戏毕业设计,java毕业设计_springboot框架的校园足球管理平台

java足球游戏毕业设计,java毕业设计_springboot框架的校园足球管理平台

今天介绍一个java毕设题目, 题目内容为springboot框架的校园足球管理平台, 是一个采用b/s结构的javaweb项目, 采用java语言编写开发工具eclipse, 项目框架jspspringbootmybatis, 校园足球管理平台的信息存储于mysql中, 并基于mybatis进行了orm封装, 该校园足球管理平台系统通过…
阅读更多...
python 爬取贝壳网小区名称_用Python爬取贝壳网新房和二手房数据

python 爬取贝壳网小区名称_用Python爬取贝壳网新房和二手房数据

[Python] 纯文本查看 复制代码import randomimport requestsfrom bs4 import BeautifulSoupimport reimport mathfrom lxml import etreeUSER_AGENTS ["Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; AcooBrowser; .NET CLR 1.1.4322; .NET CLR 2.0.50727)&q…
阅读更多...
Java 11功能– Java飞行记录器

Java 11功能– Java飞行记录器

在本文中&#xff0c;我们将看到如何利用Java Flight Recorder功能作为Java 11的一部分。之前&#xff0c;它是商业功能之一。 但是&#xff0c;对于带有JEP 328的 Java 11&#xff0c;它是开源的。 Java Flight Recorder将OS和JVM事件记录到一个文件中&#xff0c;可以使用Jav…
阅读更多...
MATLAB slider中的数值,在微信小程序中如何使用slider设置数据值

MATLAB slider中的数值,在微信小程序中如何使用slider设置数据值

这篇文章主要介绍了微信小程序使用slider设置数据值及switch开关组件功能,结合实例形式分析了slider组件及switch组件的功能与使用方法,并附带源码供读者下载参考,需要的朋友可以参考下本文实例讲述了微信小程序使用slider设置数据值及switch开关组件功能。分享给大家供大家参考…
阅读更多...
qstandarditemmodel 重写data函数后无法实现拖拽_实现类似百度网盘上传的功能

qstandarditemmodel 重写data函数后无法实现拖拽_实现类似百度网盘上传的功能

今天写到了上传文件部分&#xff0c;记录一下。前端使用了dropzone.js(用于实现文件上传的JS库)&#xff0c;并对此文件进行了细微修改。说一下思路吧&#xff1a;首先界面长这样&#xff1a;点击上传文件&#xff0c;需要弹出一个对话框&#xff0c;对话框中有支持拖拽文件的文…
阅读更多...
逻辑斯蒂回归_逻辑斯蒂回归详细解析 | 统计学习方法学习笔记 | 数据分析 | 机器学习...

逻辑斯蒂回归_逻辑斯蒂回归详细解析 | 统计学习方法学习笔记 | 数据分析 | 机器学习...

本文包括&#xff1a;重要概念逻辑斯蒂回归和线性回归二项逻辑斯谛回归模型逻辑斯蒂回顾与几率模型参数估计多项逻辑斯谛回归其它有关数据分析&#xff0c;机器学习的文章及社群1.重要概念&#xff1a;在正式介绍逻辑斯蒂回归模型之前&#xff0c;需要先对一些基本概念有所了解…
阅读更多...
mysql 数据传输 定时,MySQL数据库定时备份的实现方法

mysql 数据传输 定时,MySQL数据库定时备份的实现方法

1. 创建shell脚本2. 给shell脚本添加执行权限3. 给脚本添加定时任务crontab文件的说明&#xff1a;用户创建的crontab文件中&#xff0c;每一行都代表一项定时任务&#xff0c;每行的每个字段代表一项设置&#xff0c;它的格式每行共分为六个字段&#xff0c;前五段是时间设定字…
阅读更多...
python 生意_本周互联网关注(2015515):劳动人民的生意经、python好还是go好

python 生意_本周互联网关注(2015515):劳动人民的生意经、python好还是go好

我很喜欢写这种类型的文章&#xff0c;写的也轻松&#xff0c;大家看的也多。性价比高。那么现在继续。一、所谓光辉岁月&#xff0c;不是波澜壮阔的时候&#xff0c;而是无人问津时&#xff0c;你对梦想的坚持。| 陈欧很多人刚开始创业时激情无比高涨&#xff0c;干着干着开始…
阅读更多...
mysql空洞数据,Mysql 表空间和 数据页空洞

mysql空洞数据,Mysql 表空间和 数据页空洞

一、表空间1、表空间&#xff1a; innodb 引擎存储的最高层&#xff1b; 存放所有的数据2、独立表空间&#xff1a;Mysql 版本5.6 后默认开启的单表单空间(1)Innodb 默认存储引擎页的大小为 16K &#xff1b;默认表空间 大小为96k(2)独立表空间 开启方式 innodb_file_per_table…
阅读更多...
junit 5测试异常处理_在JUnit中处理异常的3种方式。 选择哪一个？

junit 5测试异常处理_在JUnit中处理异常的3种方式。 选择哪一个？

junit 5测试异常处理在JUnit中&#xff0c;有3种流行的方式来处理测试代码中的异常&#xff1a; 试捕习语 使用JUnit规则 带注解 我们应该使用哪一个&#xff1f;何时使用&#xff1f; 试捕习语 这个习语是最受欢迎的习语之一&#xff0c;因为它已在JUnit 3中使用。 Test…
阅读更多...
最新文章

Copyright @ 2022~2023