回溯法求解N皇后问题及其时间复杂度分析

2024-08-24 15:48
文章标签 分析 问题 复杂度 时间 皇后 求解 回溯

本文主要是介绍回溯法求解N皇后问题及其时间复杂度分析，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

回溯法求解N皇后问题及其时间复杂度分析

  • 一、回溯法简介
    • 1. 什么是回溯法？
    • 2. 回溯法的时间复杂度分析
      • 蒙特卡罗方法
      • 蒙特卡罗方法在回溯法求解时间复杂度中的应用
  • 二、回溯法求解N皇后问题
    • 1. 回溯法求解N皇后问题的过程
    • 2. 回溯法求解N皇后问题的时间复杂度
      • 2.1 求解时的效率分析
        • 回溯法进行效率分析的代码
      • 2.2 时间复杂度分析

一、回溯法简介

1. 什么是回溯法？

  相信"迷宫"是许多人儿时的回忆，大家小时候一定都玩过迷宫游戏。我们从不用别人教导，都知道走迷宫的策略是：

  1. 当遇到一个岔路口，会有以下两种情况：
    1. 存在没走过的路。此时可以任意选一条没走过的路深入，只要记住我们所走过的路径即可。倘若下次再来到这个路口，便不再沿着走过的路径继续深入，而是沿着没走过的路径深入下去；
    2. 所有路都已经走过。如果所有岔路口都已经遍历，则回退至上一个最近的岔路口。
  2. 当遇到死胡同，便回退到刚才距离最近的岔路口。
  3. 不断前进并重复该过程，直到找到终点或回退到起点位置。

  其实，这就是回溯法——一个基于深度优先搜索和约束函数的问题求解方法。

2. 回溯法的时间复杂度分析

  众所周知，回溯法的时间复杂度主要取决于如下几点：

  1. 生成每个节点x[k]（x[k]表示第k层的当前节点）所用的时间。
  2. 满足约束函数（用约束函数剪去得不到可行解的子树）的x[k]值的个数（第k层有可能生成几个这样的节点）。
  3. 计算约束函数Constraint对节点进行判断的时间。
  4. 计算上界(限界)函数Bound的时间。
  5. 满足约束函数和限界函数的所有节点x[k]的个数。

  当问题和算法一旦确定下来，就只剩下第5点的实际产生的节点数目是根据问题的具体实例而动态生成，不可预知的。
  对于一个具体的问题实例，很难预测出回溯法的行为（先选哪一条岔路，这条岔路是否能很快得到最优解），这时应该怎么办呢？

蒙特卡罗方法

  此时，可以使用蒙特卡罗方法估计回溯法产生的节点数目。
  所谓蒙特卡罗方法，其实就是一种以概率统计理论为指导的，使用随机数（或伪随机数）来解决计算问题的方法，通过对大量随机试验求平均，以求得相近的值。
  蒙特卡罗方法的基本思想是：当求解的问题是某种随机事件出现的概率或数学期望时，通过大量“实验”的方法，以频率估计概率或者得到某些数字特征，将其近似看作问题的解。
  1777年，法国数学家布丰(Buffon)提出使用投针试验的方法求解圆周率π，这被认为是蒙特卡罗方法的起源（扯远了）。

蒙特卡罗方法在回溯法求解时间复杂度中的应用

  我们需要估计的是回溯法实际产生的节点数目，以此计算回溯法的时间复杂度。
  其主要思想是，在解空间树（状态空间树）上动态、随机的产生一条路径，然后沿此路径来估算解空间树中所有满足约束条件的节点总数（这里计算的是最差时间复杂度，假设要走遍所有满足约束条件的节点）。
  多次进行上述实验，对结果求平均值，即可得到回溯法中实际生成的节点数目的估计值。

二、回溯法求解N皇后问题

1. 回溯法求解N皇后问题的过程

  问题背景：8皇后问题是由国际西洋棋棋手马克斯·贝瑟尔于1848年提出的问题，是回溯算法的典型案例。N皇后问题由此推广而来。
  问题描述：在N×N格的国际象棋上摆放N个皇后，使其不能互相攻击，即不能处于同一列或同一行，也不能处在同一斜线上，请问有多少种摆法？
8皇后问题

  N皇后问题也是回溯算法的典型案例，这里，我们可以使用递归和循环迭代两种不同的回溯方式编写代码：

//
//  main.cpp
//  BackTrack Solution of N-Queens Problem.
//
//  Created by Kang on 2020/7/2 at NJUPT.
//  Copyright © 2020 Kang. All rights reserved.
//#include <iostream>
#include <cmath>
#include <ctime>
using namespace std;const int maxSize = 10;
int x[maxSize];/**Judge if the Queen can be placed at (k, x[k]), if OK, return true.*/
bool CanPlace(int k){for(int i = 0; i < k; ++i) {if(x[i] == x[k] || abs(i-k) == abs(x[i]-x[k]))return false;}return true;
}void Print(int N){for (int i = 0; i < N; ++i) {for (int j = 0; j < N; ++j) {if(x[i] != j) {printf(" ");} else {printf("▇\n");break;}}}printf("---------\n");
}/**k the current deepth( from 0 to n-1) in the Solution Space Tree*/
int Recursive_BackTrack(int k, int N){int solutionCount = 0;if(k == N){Print(N);return 1;}for (int i = 0; i < N; ++i) {x[k] = i;if(CanPlace(k)){solutionCount += Recursive_BackTrack(k+1, N);}}return solutionCount;
}int Iterated_BackTrack(int N){int solutionCount = 0, k = 0;       // 问题解的个数、当前层数for (int i = 0; i < maxSize; ++i) { // 将所有层中，所选子树(列)的初始值置为-1x[i] = -1;}while (k > -1) {     // 如果已经退回第0行前面，则结束遍历if(k == N){      // 如果已经超过最后一行，则打印路径并返回上一层Print(N);++solutionCount;--k;continue;}if(++x[k] < N){  // 如果还有未访问的子节点，则选择这棵树的下一个子树if(CanPlace(k)){++k;     // 如果当前位置可以摆放，则k自增，进入下一行的循环。} else {// 如果当前位置不能摆放，则k不必动，直接进入下次循环。}} else {         // 子树已经全部搜索，返回上一层x[k] = -1;   // 注意，返回时要将子树进行复位。--k;}}return solutionCount;
}int main(int argc, const char * argv[]) {int N;int count;printf("请输入皇后个数：");scanf("%d", &N);// count = Recursive_BackTrack(0, N);count = Iterated_BackTrack(N);cout<<"共有"<<count<<"种不同的解法。"<<endl;return 0;
}

  笔者在写博客的过程中发现了可以优化的地方，于是赶快去修改了一下。不知道各位读者有没有发现，各位可以仔细对比以下两份不同的代码，答案将在这份代码后面给出。

//
//  optimisedMain.cpp
//  Optimised BackTrack Solution of N-Queens Problem.
//
//  Created by Kang on 2020/7/2 at NJUPT.
//  Copyright © 2020 Kang. All rights reserved.
//#include <iostream>
#include <cmath>
#include <ctime>
using namespace std;const int maxSize = 10;      // 最大能输入的棋盘规模（皇后数量）
int x[maxSize];              // x[k]表示：第k行选择第x[k]列
int flag[maxSize][maxSize];  // flag[k][i]：第k行的第i列如果可选则为1，不可选则为0/**Calculate the kth row's all unalternative column i, and turn flag[i] from 1 to 0.*/
void calcFlag(int k, int N){for (int i = 0; i < N; ++i) {flag[k][i] = 1;}for(int i = 0; i < k; ++i) { // from 0th to (k-1)th rowflag[k][x[i]] = 0;  // 正对下方的列直接Passif(x[i] + abs(i-k) < N)   // 检查右下方：如果当前列号x[i] + 行差abs(i-k) < Nflag[k][x[i] + abs(i-k)] = 0;if (x[i] - abs(i-k) > -1) // 检查左下方：如果当前列号x[i] + 行差abs(i-k) < Nflag[k][x[i] - abs(i-k)] = 0;}
}void Print(int N){for (int i = 0; i < N; ++i) {for (int j = 0; j < N; ++j) {if(x[i] != j) {printf(" ");} else {printf("▇\n");break;}}}printf("---------\n");
}/**k the current deepth( from 0 to n-1) in the Solution Space TreeN the scale of the problemreturn number of solution*/
int Recursive_BackTrack(int k, int N){int solutionCount = 0;if(k == N){Print(N);return 1;}calcFlag(k, N);for (int i = 0; i < N; ++i) {if(flag[k][i]) {x[k] = i;solutionCount += Recursive_BackTrack(k+1, N);}}return solutionCount;
}/**N the scale of the problemreturn number of solution
*/
int Iterated_BackTrack(int N){int solutionCount = 0, k = 0;       // 问题解的个数、当前层数for (int i = 0; i < maxSize; ++i) { // 将所有层中，所选子树(列)的初始值置为-1x[i] = -1;}calcFlag(0, N);while (k > -1) {     // 如果已经退回第0行前面，则结束遍历if(k == N){      // 如果已经超过最后一行，则打印路径并返回上一层Print(N);++solutionCount;--k;continue;}if(++x[k] < N){  // 如果还有未访问的子节点，则选择这棵树的下一个子树if (flag[k][x[k]] == 1) {++k;     // 如果当前列x[k]可以摆放，则k自增，进入下一行的循环。calcFlag(k, N);} else {// 如果当前位置不能摆放，则k不必动，直接进入下次循环。}} else {         // 子树已经全部搜索，返回上一层x[k--] = -1;   // 注意，返回时要将子树进行复位。}}return solutionCount;
}int main(int argc, const char * argv[]) {int N;int count;printf("请输入皇后个数：");scanf("%d", &N);//count = Recursive_BackTrack(0, N);count = Iterated_BackTrack(N);cout<<"共有"<<count<<"种不同的解法。"<<endl;return 0;
}

  Answer：这其实是一种添加辅助数组flag，从而牺牲空间复杂度O(n2)，减小时间复杂度n倍的策略。这样，每一个位置判断是否可以摆放，只需要O(1)的时间复杂度，而非前者O(n)的时间复杂度（以下计算时间复杂度时，均采用的是后者的求解方式）。

2. 回溯法求解N皇后问题的时间复杂度

  根据前面所讲到的蒙特卡罗方法，此时可以将其用于求解N皇后的时间复杂度。对于n元组长度的问题实例，其状态空间树中的节点数目常见的有n!(排列树)、an(子集树)和nn(可复选的排列树)，则回溯算法的最坏时间复杂度分别为：

  • O(p(n) * n!)
  • O(p(n) * 2n)
  • O(p(n) * nn)

其中，p(n)表示生成一个节点所需的时间复杂度。

  虽然回溯法的最坏时间复杂度非常的大，但是在大多数情况下，通常不需要生成状态空间树中的全部节点，而是通过约束函数和限界函数进行剪枝，从而最终只生成状态空间树中很少量的一部分节点，这里，我们就使用N皇后问题来举例，利用蒙特卡罗方法估算一下算法运行中实际生成的节点占状态空间树中总节点的比例。

2.1 求解时的效率分析

  在求解时间复杂度之前，先分析一下回溯法的效率。回溯法的运行时间通常取决于状态空间树上实际生成的那部分节点的数目。
  在n皇后问题中，状态空间树(排列树)中总的节点个数为（如图为4皇后问题的完整的解空间树，共有65个节点）：

  • 1+n+(n-1)+(n-2)+ ······ +[n-(n-2)]+[n-(n-1)]

在这里插入图片描述

而实际生成的节点数的个数怎么计算呢？
不妨对4-皇后问题先演算一下~
在这里插入图片描述
计算得到4皇后问题实际生成的节点数为16个，只生成了 (16/65)*100% = 24.6% 的节点。

  但实际上，我们在通常的问题中无法预知要从哪一条岔路开始搜索解(这里很简单我们从0位置开始向后)，而且有的时候我们要求出所有符合条件的解，这就要求我们将状态空间树中所有符合剪枝函数的点全部计算进来。

  如果要计算实际生成的节点数，那么问题来了：

  1. 当我遇到岔路的时候，会随机走一条路，请问我走了哪条路？
  2. 我也是走一步之后，才知道下一步的有几个岔路或者是否是死胡同。

  这时，蒙特卡罗方法就派上用场了。既然我们不清楚要生成多少节点，那我们不妨进行若干次的试验，然后求平均：每次随机生成一条路径，根据这条路径的情况来草率的推断所有其他路径和这条路一样，从而草率的估计实际生成的节点数量。
  很显然，对于8皇后来说，第一行选第0个位置和选第1个位置，从而造成的第2行所能选择的范围都不一样，所以说是“草率的”估计。
  但是这么草率的估计是否严谨呢？单单试验一次，恐怕并不严谨。但是，如果我们进行大量的试验，然后对这一整批实验数据求平均，从概率论上来说，试验次数越多，结果越准确（例如，投硬币次数越多，正面朝上的频率越稳定于实际的概率0.5）。

  那我们不妨就用实际的栗子，来对8皇后问题进行一个“草率的”估计。这里简单的用(a)图进行举例：

  • 根节点1个（假定为状态空间树的第0行）；
  • 第一行可以有8种选择(0, 1, 2, 3, 4, 5, 6, 7)，所以状态空间树的第1行有8个节点。此时，假设我们随机选择了当前可行的1号位置；
  • 在第一行的基础上，我们有5种选择(3, 4, 5, 6, 7)，这时可以“草率的”假设：对于每一种第一行的可行的选择（8种），我们在第二行都有5种不同的选择，所以状态空间树的第二行我们可以生成8*5个节点。此时，假设我们随机选择了当前可行的3号位置；
  • 在前两行的基础上，我们有4种选择(0, 5, 6, 7)，这时可以“草率的”假设：对于每一种前两行的可行排列(8*5=40)，我们在第三行都有4种不同的选择，所以状态空间树的第三行有8*5*4个节点。此时，假设我们随机选择了当前可行的0号位置；
  • 在前三行的基础上，我们有3种选择(2, 6, 7)，这时可以“草率的”假设：对于每一种前三行的可行排列(8*5*4=160)，我们在第四行都有3种不同的选择，所以状态空间树的第4行有8*5*4*3=480个节点。此时，假设我们随机选择了当前可行的2号位置；
  • 在前四行的基础上，我们有2种选择(4, 7)，这时可以“草率的”假设：对于每一种前四行的可行排列(8*5*4*3=480)，我们在第四行都有3种不同的选择，所以状态空间树的第5行有480*2=480个节点。此时，假设我们随机选择了当前可行的4号位置；
  • 在前五行的基础上，我们已经没有任何选择了，所以我们“草率的”假设，其他所有的路径都和这条路径一样，都无法继续选择了，所以状态空间树从第6行开始不再实际产生节点。

  因此，我们“草率的”估计，此次随机试验，解空间树中实际产生的节点数量有1+8+8*5+8*5*4+8*5*4*3+8*5*4*3*2 = 1649个，占总节点数8!/8!+8!/7!+8!/6!+······+8!/2!+8!/1!+8!/0!=109601的1.55%。在这里插入图片描述
  此时，我们是否可以说回溯法一定就实际生成1.55%的节点数呢？答案是否定的。我们需要尽可能的做多次这样的随机试验（例如b、c、d、e等图），然后求出平均值，才是较为准确的实际生成的节点占比。（其他几个图随机的路径也是一样的道理，笔者此处不再赘述。）

回溯法进行效率分析的代码

  此处贴上本人手写的代码一份，可以用于测试实际生成的节点与状态空间树中总结点的占比，有疑问欢迎私信。

//
//  rate.cpp
//  Efficiency Analysis of BackTrack for N-Queens Problem.
//
//  Created by Kang on 2020/7/2 at NJUPT.
//  Copyright © 2020 Kang. All rights reserved.
//#include <iostream>
#include <cmath>
#include <ctime>
using namespace std;const int testCount = 100; // 测试次数
const int MAXN = 20;       // 能测试的皇后最大值
int countPerRow[MAXN];     // 存放每行能选列的个数，便于最终计算结果
int bucket[MAXN];          // 符合约束能选则为1，不符合约束不能选则为0
int x[MAXN];               // 存放生成的随机序列
int N;                     // 本次是N皇后求解// 初始化临时标记是否是可选的列
// 每行的判定开始前，都需要调用，假定该行的每一列都不能选
void initBucket(){for(int i = 0; i < MAXN; ++i) {bucket[i] = 0;}
}// 初始化每行能选的列数，每次试验开始前调用，进行置零
void initCountPerRow(){    for(int i = 0; i < MAXN; ++i) {countPerRow[i] = 0;}
}bool CanPlace(int k) {   // 判断第k行第x[k]列能不能放for (int i = 0; i < k; ++i) {if (x[i] == x[k] || abs(i - k) == abs(x[i] - x[k]))   // 是否下面和斜对角有重合return false;}return true;
}// 返回能够抵达的行数
int RecurBacktrackM(int t) {initBucket();if (t == N) {            // 如果已经进入第N+1行，则找到解return t;} else {int colCount = 0;    // 能摆放几列int randInt, r = 0;  // 随机第几个能摆放的位置int index = 0;       // 摆放的位置的下标for (int i = 0; i < N; ++i) {      // 挨个试探x[t] = i;if (CanPlace(t)) {             // 判断是否能放bucket[i] = 1;colCount++;countPerRow[t]++;          // 第t行实际产生的可行解数量++}}if(colCount > 0) {                 // 如果这一行有可行解randInt = rand()%colCount + 1;while(r < randInt){if(bucket[index] == 1){r++;}index++;}index--;x[t] = index;                 // 得到随机选择的可行解的列号return RecurBacktrackM(t + 1);// 进入下一层} else {                          // 不能放说明是死胡同，直接返回return t;}}
}int main() {srand((unsigned)time(NULL));cout<<"请输入棋盘的大小：";cin>>N;double allRate = 0;for(int number = 0; number < testCount; number++){int row, allNodeCount = 1;int geneNodeCount = 1;   // 蒙特卡洛估计的，实际产生的节点的数量initCountPerRow();row = RecurBacktrackM(0);cout<<"本次实验的随机序列是：";for(int i = 0; i < row; i++){cout<<x[i]<<" ";}cout<<endl;int tmp;cout<<"本次实验的每行节点数分别是：";for(int i = 0; i < row; i++){cout<<countPerRow[i]<<" ";}cout<<endl;for(int i = 0; i < row; i++) {tmp = 1;for(int j = 0; j <= i; j++) {tmp *= countPerRow[j];}geneNodeCount += tmp;}cout<<"本次估计实际产生的节点数是："<<geneNodeCount<<endl;for(int i = 0; i < N; i++) {tmp = 1;for(int j = 0; j <= i; j++) {tmp *= N-j;}allNodeCount += tmp;}cout<<"    状态空间树中的总节点数是："<<allNodeCount<<endl;cout<<"    实际生成节点数目与总节点数比值为："<<((geneNodeCount * 1.0)/allNodeCount)*100<<"%"<<endl;allRate += (geneNodeCount * 1.0)/allNodeCount;cout<<"-----------------------------------------------"<<endl;}cout<<"此"<<testCount<<"次实验，平均实际生成节点数目与总节点数比值为："<<(allRate/testCount)*100<<"%"<<endl;return 0;
}

运行1000次8皇后问题的试验，效果截图如下：
在这里插入图片描述

2.2 时间复杂度分析

  在N皇后问题中，因为每个节点（最下一层除外）都要遍历包括当前层在内的上面每一层的选择，才能得到当前可行的全部直接子孙节点，且绝大多数节点都集中在层数靠下的位置，故可以估计出平均每个节点的生成时间复杂度p(n)都是n。
  例如上例中，根节点生成时要检验它的8个真子孙节点是否可行；对于第一层的每一个节点，也都需要判断其全部的8个真子孙节点是否可行；第二层、第三层······直到倒数第二层，也都需要判断其全部的8个真子孙节点是否可行；最后一层虽比较特殊，无需判断，但最后一层（已经抵达可行解）的节点在N皇后问题(排列树)中和上一层的节点数相同，故与其他节点一视同仁也不影响时间复杂度的计算。
  所以N皇后的时间复杂度为O(n×实际生成的节点数)。

  凑巧赶上小破邮的算法课程，于是写下人生中第一篇正式的CSDN博客，竟然啰嗦了1w多字，希望大家多多点赞支持，有疑问的地方欢迎私信小博同学进行交流奥~

我的博客即将同步至腾讯云开发者社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=2x08l67hcieck

这篇关于回溯法求解N皇后问题及其时间复杂度分析的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1102912。

相关文章

服务器集群同步时间手记

服务器集群同步时间手记

1.时间服务器配置（必须root用户） （1）检查ntp是否安装 [root@node1 桌面]# rpm -qa|grep ntpntp-4.2.6p5-10.el6.centos.x86_64fontpackages-filesystem-1.41-1.1.el6.noarchntpdate-4.2.6p5-10.el6.centos.x86_64 （2）修改ntp配置文件 [r
阅读更多...
好题——hdu2522（小数问题：求1/n的第一个循环节）

好题——hdu2522（小数问题：求1/n的第一个循环节）

好喜欢这题，第一次做小数问题，一开始真心没思路，然后参考了网上的一些资料。 知识点***********************************无限不循环小数即无理数，不能写作两整数之比*****************************（一开始没想到，小学没学好） 此题1/n肯定是一个有限循环小数，了解这些后就能做此题了。 按照除法的机制，用一个函数表示出来就可以了，代码如下
阅读更多...
hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

利用康拓展开将一个排列映射成一个自然数，然后就变成了普通的广搜题。 #include<iostream>#include<algorithm>#include<string>#include<stack>#include<queue>#include<map>#include<stdio.h>#include<stdlib.h>#include<ctype.h>#inclu
阅读更多...
性能分析之MySQL索引实战案例

性能分析之MySQL索引实战案例

文章目录 一、前言二、准备三、MySQL索引优化四、MySQL 索引知识回顾五、总结 一、前言 在上一讲性能工具之 JProfiler 简单登录案例分析实战中已经发现SQL没有建立索引问题，本文将一起从代码层去分析为什么没有建立索引？ 开源ERP项目地址：https://gitee.com/jishenghua/JSH_ERP 二、准备 打开IDEA找到登录请求资源路径位置
阅读更多...
购买磨轮平衡机时应该注意什么问题和技巧

购买磨轮平衡机时应该注意什么问题和技巧

在购买磨轮平衡机时，您应该注意以下几个关键点： 平衡精度 平衡精度是衡量平衡机性能的核心指标，直接影响到不平衡量的检测与校准的准确性，从而决定磨轮的振动和噪声水平。高精度的平衡机能显著减少振动和噪声，提高磨削加工的精度。 转速范围 宽广的转速范围意味着平衡机能够处理更多种类的磨轮，适应不同的工作条件和规格要求。 振动监测能力 振动监测能力是评估平衡机性能的重要因素。通过传感器实时监
阅读更多...
缓存雪崩问题

缓存雪崩问题

缓存雪崩是缓存中大量key失效后当高并发到来时导致大量请求到数据库，瞬间耗尽数据库资源，导致数据库无法使用。 解决方案： 1、使用锁进行控制 2、对同一类型信息的key设置不同的过期时间 3、缓存预热 1. 什么是缓存雪崩 缓存雪崩是指在短时间内，大量缓存数据同时失效，导致所有请求直接涌向数据库，瞬间增加数据库的负载压力，可能导致数据库性能下降甚至崩溃。这种情况往往发生在缓存中大量 k
阅读更多...
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

上篇：6.1.数据结构-c/c++模拟实现堆上篇（向下，上调整算法，建堆，增删数据）-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小)： 2.2 C语言代码（手写堆） 2.3 C++代码（使用优先级队列 priority_queue）
阅读更多...
SWAP作物生长模型安装教程、数据制备、敏感性分析、气候变化影响、R模型敏感性分析与贝叶斯优化、Fortran源代码分析、气候数据降尺度与变化影响分析

SWAP作物生长模型安装教程、数据制备、敏感性分析、气候变化影响、R模型敏感性分析与贝叶斯优化、Fortran源代码分析、气候数据降尺度与变化影响分析

查看原文>>>全流程SWAP农业模型数据制备、敏感性分析及气候变化影响实践技术应用 SWAP模型是由荷兰瓦赫宁根大学开发的先进农作物模型，它综合考虑了土壤-水分-大气以及植被间的相互作用；是一种描述作物生长过程的一种机理性作物生长模型。它不但运用Richard方程，使其能够精确的模拟土壤中水分的运动，而且耦合了WOFOST作物模型使作物的生长描述更为科学。 本文让更多的科研人员和农业工作者
阅读更多...
MOLE 2.5 分析分子通道和孔隙

MOLE 2.5 分析分子通道和孔隙

软件介绍 生物大分子通道和孔隙在生物学中发挥着重要作用，例如在分子识别和酶底物特异性方面。 我们介绍了一种名为 MOLE 2.5 的高级软件工具，该工具旨在分析分子通道和孔隙。 与其他可用软件工具的基准测试表明，MOLE 2.5 相比更快、更强大、功能更丰富。作为一项新功能，MOLE 2.5 可以估算已识别通道的物理化学性质。 软件下载 https://pan.quark.cn/s/57
阅读更多...
衡石分析平台使用手册-单机安装及启动

衡石分析平台使用手册-单机安装及启动

单机安装及启动​ 本文讲述如何在单机环境下进行 HENGSHI SENSE 安装的操作过程。 在安装前请确认网络环境，如果是隔离环境，无法连接互联网时，请先按照 离线环境安装依赖的指导进行依赖包的安装，然后按照本文的指导继续操作。如果网络环境可以连接互联网，请直接按照本文的指导进行安装。 准备工作​ 请参考安装环境文档准备安装环境。 配置用户与安装目录。 在操作前请检查您是否有 sud
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2