0047算法笔记——【随机化算法】拉斯维加斯(Las Vegas)算法和n后问题

最新推荐文章于 2023-05-15 23:23:58 发布
最新推荐文章于 2023-05-15 23:23:58 发布
阅读量2k 收藏 17
点赞数 1
分类专栏： 数据结构与算法

      1、拉斯维加斯(Las Vegas)算法

     拉斯维加斯算法不会得到不正确的解。一旦用拉斯维加斯算法找到一个解，这个解就一定是正确解。但有时用拉斯维加斯算法找不到解。与蒙特卡罗算法类似，拉斯维加斯算法找到正确解的概率随着它所用的计算时间的增加而提高。对于所求解问题的任一实例，用同一拉斯维加斯算法反复对该实例求解足够多次，可使求解失败的概率任意小。拉斯维加斯算法的一个显著特征是它所作的随机性决策有可能导致算法找不到所需的解。

[cpp] view plain copy print ?
  1. void obstinate(Object x, Object y)  
  2. {// 反复调用拉斯维加斯算法LV(x,y)，直到找到问题的一个解y   
  3.     bool success= false;  
  4.     while (!success) success=lv(x,y);  
  5. }  
void obstinate(Object x, Object y)
{// 反复调用拉斯维加斯算法LV(x,y)，直到找到问题的一个解y
    bool success= false;
    while (!success) success=lv(x,y);
}

      设p(x)是对输入x调用拉斯维加斯算法获得问题的一个解的概率。一个正确的拉斯维加斯算法应该对所有输入x均有p(x)>0。设t(x)是算法obstinate找到具体实例x的一个解所需的平均时间 ,s(x)和e(x)分别是算法对于具体实例x求解成功或求解失败所需的平均时间，则有。解此方程得：


     2、n后问题

     问题描速：在n×n格的棋盘上放置彼此不受攻击的n个皇后。按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。n后问题等价于在n×n格的棋盘上放置n个皇后，任何2个皇后不放在同一行或同一列或同一斜线上。


     1)纯拉斯维加斯随机算法求解思路

      对于n后问题的任何一个解而言，每一个皇后在棋盘上的位置无任何规律，不具有系统性，而更象是随机放置的。在棋盘上相继的各行中随机地放置皇后，并注意使新放置的皇后与已放置的皇后互不攻击，直至n个皇后均已相容地放置好，或已没有下一个皇后的可放置位置时为止。

      具体实现代码如下：

     1、RandomNumber.h

[cpp] view plain copy print ?
  1. #include"time.h"   
  2. //随机数类   
  3. const unsigned long maxshort = 65536L;  
  4. const unsigned long multiplier = 1194211693L;  
  5. const unsigned long adder = 12345L;  
  6.   
  7. class RandomNumber  
  8. {  
  9.     private:  
  10.         //当前种子   
  11.         unsigned long randSeed;  
  12.     public:  
  13.         RandomNumber(unsigned long s = 0);//构造函数，默认值0表示由系统自动产生种子  
  14.         unsigned short Random(unsigned long n);//产生0：n-1之间的随机整数  
  15.         double fRandom(void);//产生[0,1)之间的随机实数  
  16. };  
  17.   
  18. RandomNumber::RandomNumber(unsigned long s)//产生种子  
  19. {  
  20.     if(s == 0)  
  21.     {  
  22.         randSeed = time(0);//用系统时间产生种子   
  23.     }  
  24.     else  
  25.     {  
  26.         randSeed = s;//由用户提供种子   
  27.     }  
  28. }  
  29.   
  30. unsigned short RandomNumber::Random(unsigned long n)//产生0：n-1之间的随机整数  
  31. {  
  32.     randSeed = multiplier * randSeed + adder;//线性同余式  
  33.     return (unsigned short)((randSeed>>16)%n);  
  34. }  
  35.   
  36. double RandomNumber::fRandom(void)//产生[0,1)之间的随机实数  
  37. {  
  38.     return Random(maxshort)/double(maxshort);  
  39. }  
#include"time.h"
//随机数类
const unsigned long maxshort = 65536L;
const unsigned long multiplier = 1194211693L;
const unsigned long adder = 12345L;

class RandomNumber
{
	private:
		//当前种子
		unsigned long randSeed;
	public:
		RandomNumber(unsigned long s = 0);//构造函数，默认值0表示由系统自动产生种子
		unsigned short Random(unsigned long n);//产生0：n-1之间的随机整数
		double fRandom(void);//产生[0,1)之间的随机实数
};

RandomNumber::RandomNumber(unsigned long s)//产生种子
{
	if(s == 0)
	{
		randSeed = time(0);//用系统时间产生种子
	}
	else
	{
		randSeed = s;//由用户提供种子
	}
}

unsigned short RandomNumber::Random(unsigned long n)//产生0：n-1之间的随机整数
{
	randSeed = multiplier * randSeed + adder;//线性同余式
	return (unsigned short)((randSeed>>16)%n);
}

double RandomNumber::fRandom(void)//产生[0,1)之间的随机实数
{
	return Random(maxshort)/double(maxshort);
}
     2、7d4d1.cpp

[cpp] view plain copy print ?
  1. //随机化算法 拉斯维加斯算法 n后问题   
  2. #include "stdafx.h"   
  3. #include "RandomNumber.h"  
  4. #include <cmath>   
  5. #include <iostream>   
  6. using namespace std;  
  7.   
  8. class Queen  
  9. {  
  10.     friend void nQueen(int);  
  11.     private:  
  12.         bool Place(int k);      //测试皇后k置于第x[k]列的合法性  
  13.         bool QueensLv(void);    //随机放置n个皇后拉斯维加斯算法  
  14.         int n;                  //皇后个数  
  15.         int *x,*y;              //解向量  
  16. };  
  17.   
  18. //测试皇后k置于第x[k]列的合法性   
  19. bool Queen::Place(int k)  
  20. {  
  21.     for(int j=1; j<k; j++)  
  22.     {  
  23.         if((abs(k-j)==abs(x[j]-x[k]))||(x[j]==x[k]))  
  24.         {  
  25.             return false;  
  26.         }  
  27.     }  
  28.     return true;  
  29. }  
  30.   
  31. //随机放置n个皇后的拉斯维加斯算法   
  32. bool Queen::QueensLv(void)  
  33. {  
  34.     RandomNumber rnd;       //随机数产生器   
  35.     int k = 1;              //下一个皇后的编号  
  36.     int count = 1;          //在一列中，可以放置皇后的个数  
  37.   
  38.     while((k<=n)&&(count>0))  
  39.     {  
  40.         count = 0;  
  41.         for(int i=1; i<=n; i++)  
  42.         {  
  43.             x[k] = i;//位置   
  44.             if(Place(k))  
  45.             {  
  46.                 y[count++] = i;  
  47.             }  
  48.         }  
  49.         if(count>0)  
  50.         {  
  51.             x[k++] = y[rnd.Random(count)];      //随机位置  
  52.         }  
  53.     }  
  54.   
  55.     return (count>0);        //count>0 表示放置成功  
  56. }  
  57.   
  58. //解n后问题的拉斯维加斯算法   
  59. void nQueen(int n)  
  60. {  
  61.     Queen X;  
  62.     X.n = n;  
  63.   
  64.     int *p = new int[n+1];  
  65.     for(int i=0; i<=n; i++)  
  66.     {  
  67.         p[i] = 0;  
  68.     }  
  69.     X.x = p;  
  70.     X.y = new int[n+1];  
  71.   
  72.     //反复调用随机放置n个皇后的拉斯维加斯算法，直到放置成功   
  73.     while(!X.QueensLv());  
  74.   
  75.     for(int i=1; i<=n; i++)  
  76.     {  
  77.         cout<<p[i]<<" ";  
  78.     }  
  79.     cout<<endl;  
  80.     delete []p;  
  81. }  
  82.   
  83. int main()  
  84. {  
  85.     int n=8;    
  86.     cout<<n<<"皇后问题的解为："<<endl;    
  87.     nQueen(n);    
  88.     return 0;    
  89. }  
//随机化算法 拉斯维加斯算法 n后问题
#include "stdafx.h"
#include "RandomNumber.h"
#include <cmath>
#include <iostream>
using namespace std;

class Queen
{
	friend void nQueen(int);
	private:
		bool Place(int k);		//测试皇后k置于第x[k]列的合法性
		bool QueensLv(void);	//随机放置n个皇后拉斯维加斯算法
		int n;					//皇后个数
		int *x,*y;				//解向量
};

//测试皇后k置于第x[k]列的合法性
bool Queen::Place(int k)
{
	for(int j=1; j<k; j++)
	{
		if((abs(k-j)==abs(x[j]-x[k]))||(x[j]==x[k]))
		{
			return false;
		}
	}
	return true;
}

//随机放置n个皇后的拉斯维加斯算法
bool Queen::QueensLv(void)
{
	RandomNumber rnd;		//随机数产生器
	int k = 1;				//下一个皇后的编号
	int count = 1;			//在一列中，可以放置皇后的个数

	while((k<=n)&&(count>0))
	{
		count = 0;
		for(int i=1; i<=n; i++)
		{
			x[k] = i;//位置
			if(Place(k))
			{
				y[count++] = i;
			}
		}
		if(count>0)
		{
			x[k++] = y[rnd.Random(count)];		//随机位置
		}
	}

	return (count>0);		//count>0 表示放置成功
}

//解n后问题的拉斯维加斯算法
void nQueen(int n)
{
	Queen X;
	X.n = n;

	int *p = new int[n+1];
	for(int i=0; i<=n; i++)
	{
		p[i] = 0;
	}
	X.x = p;
	X.y = new int[n+1];

	//反复调用随机放置n个皇后的拉斯维加斯算法，直到放置成功
	while(!X.QueensLv());

	for(int i=1; i<=n; i++)
	{
		cout<<p[i]<<" ";
	}
	cout<<endl;
	delete []p;
}

int main()
{
	int n=8;  
    cout<<n<<"皇后问题的解为："<<endl;  
    nQueen(n);  
    return 0;  
}
     程序运行结果如下：


     2)与回溯法结合的拉斯维加斯随机算法求解思路

     如果将上述随机放置策略与回溯法相结合，可能会获得更好的效果。可以先在棋盘的若干行中随机地放置皇后，然后在后继行中用回溯法继续放置，直至找到一个解或宣告失败。随机放置的皇后越多，后继回溯搜索所需的时间就越少，但失败的概率也就越大。 

　 算法具体代码如下：

    1、RandomNumber.h如上

    2、7d4d1-2.cpp

[cpp] view plain copy print ?
  1. //随机化算法 拉斯维加斯算法 n后问题   
  2. #include "stdafx.h"   
  3. #include "RandomNumber.h"  
  4. #include <cmath>   
  5. #include <iostream>   
  6. using namespace std;  
  7.   
  8. class Queen  
  9. {  
  10.     friend bool nQueen(int);  
  11.     private:  
  12.         bool Place(int k);                  //测试皇后k置于第x[k]的合法性  
  13.         bool Backtrack(int t);              //解n后问题的回溯法  
  14.         bool QueensLV(int stopVegas);       //随机放置n个皇后拉斯维加斯算法  
  15.         int n,*x,*y;  
  16. };  
  17.   
  18. //测试皇后k置于第x[k]列的合法性   
  19. bool Queen::Place(int k)  
  20. {  
  21.     for(int j=1; j<k; j++)  
  22.     {  
  23.         if((abs(k-j)==abs(x[j]-x[k]))||(x[j]==x[k]))  
  24.         {  
  25.             return false;  
  26.         }  
  27.     }  
  28.     return true;  
  29. }  
  30.   
  31. //解n后问题的回溯法   
  32. bool Queen::Backtrack(int t)  
  33. {  
  34.     if(t>n)  
  35.     {  
  36.         for(int i=1; i<=n; i++)  
  37.         {  
  38.             y[i] = x[i];//问题的解   
  39.         }  
  40.         return true;  
  41.     }  
  42.     else  
  43.     {  
  44.         for(int i=1; i<=n; i++)  
  45.         {  
  46.             x[t] = i;  
  47.             if(Place(t)&&Backtrack(t+1))  
  48.             {  
  49.                 return true;  
  50.             }  
  51.         }  
  52.     }  
  53.     return false;  
  54. }  
  55.   
  56.   
  57. //随机放置n个皇后拉斯维加斯算法   
  58. bool Queen::QueensLV(int stopVegas)  
  59. {  
  60.     RandomNumber rnd;       //随机数产生器   
  61.     int k = 1;  
  62.     int count = 1;  
  63.   
  64.     //1<=stopVegas<=n   
  65.     while((k<=stopVegas)&&(count>0))  
  66.     {  
  67.         count = 0;  
  68.         for(int i=1; i<=n; i++)  
  69.         {  
  70.             x[k] = i;  
  71.             if(Place(k))  
  72.             {  
  73.                 y[count++] = i;  
  74.             }  
  75.         }  
  76.   
  77.         if(count>0)  
  78.         {  
  79.             x[k++] = y[rnd.Random(count)];//随机位置  
  80.         }  
  81.     }  
  82.     return (count>0);        //count>0表示放置成功  
  83. }  
  84.   
  85. //与回溯法相结合的解n后问题的拉斯维加斯算法   
  86. bool nQueen(int n)  
  87. {  
  88.     Queen X;  
  89.       
  90.     //初始化X   
  91.     X.n = n;  
  92.   
  93.     int *p = new int[n+1];  
  94.     int *q = new int[n+1];  
  95.   
  96.     for(int i=0; i<=n; i++)  
  97.     {  
  98.         p[i] = 0;  
  99.         q[i] = 0;  
  100.     }  
  101.   
  102.     X.y = p;  
  103.     X.x = q;  
  104.   
  105.     int stop = 3;  
  106.     if(n>15)  
  107.     {  
  108.         stop = n-15;  
  109.     }  
  110.   
  111.     bool found = false;  
  112.     while(!X.QueensLV(stop));  
  113.   
  114.     //算法的回溯搜索部分   
  115.     if(X.Backtrack(stop+1))  
  116.     {  
  117.         for(int i=1; i<=n; i++)  
  118.         {  
  119.             cout<<p[i]<<" ";  
  120.         }  
  121.         found = true;  
  122.         cout<<endl;  
  123.     }  
  124.       
  125.     delete []p;  
  126.     delete []q;  
  127.     return found;  
  128. }  
  129.   
  130. int main()  
  131. {  
  132.     int n=8;    
  133.     cout<<n<<"皇后问题的解为："<<endl;    
  134.     while(!nQueen(n));    
  135.     return 0;    
  136. }  
//随机化算法 拉斯维加斯算法 n后问题
#include "stdafx.h"
#include "RandomNumber.h"
#include <cmath>
#include <iostream>
using namespace std;

class Queen
{
	friend bool nQueen(int);
	private:
		bool Place(int k);					//测试皇后k置于第x[k]的合法性
		bool Backtrack(int t);				//解n后问题的回溯法
		bool QueensLV(int stopVegas);		//随机放置n个皇后拉斯维加斯算法
		int n,*x,*y;
};

//测试皇后k置于第x[k]列的合法性
bool Queen::Place(int k)
{
	for(int j=1; j<k; j++)
	{
		if((abs(k-j)==abs(x[j]-x[k]))||(x[j]==x[k]))
		{
			return false;
		}
	}
	return true;
}

//解n后问题的回溯法
bool Queen::Backtrack(int t)
{
	if(t>n)
	{
		for(int i=1; i<=n; i++)
		{
			y[i] = x[i];//问题的解
		}
		return true;
	}
	else
	{
		for(int i=1; i<=n; i++)
		{
			x[t] = i;
			if(Place(t)&&Backtrack(t+1))
			{
				return true;
			}
		}
	}
	return false;
}


//随机放置n个皇后拉斯维加斯算法
bool Queen::QueensLV(int stopVegas)
{
	RandomNumber rnd;		//随机数产生器
	int k = 1;
	int count = 1;

	//1<=stopVegas<=n
	while((k<=stopVegas)&&(count>0))
	{
		count = 0;
		for(int i=1; i<=n; i++)
		{
			x[k] = i;
			if(Place(k))
			{
				y[count++] = i;
			}
		}

		if(count>0)
		{
			x[k++] = y[rnd.Random(count)];//随机位置
		}
	}
	return (count>0);		//count>0表示放置成功
}

//与回溯法相结合的解n后问题的拉斯维加斯算法
bool nQueen(int n)
{
	Queen X;
	
	//初始化X
	X.n = n;

	int *p = new int[n+1];
	int *q = new int[n+1];

	for(int i=0; i<=n; i++)
	{
		p[i] = 0;
		q[i] = 0;
	}

	X.y = p;
	X.x = q;

	int stop = 3;
	if(n>15)
	{
		stop = n-15;
	}

	bool found = false;
	while(!X.QueensLV(stop));

	//算法的回溯搜索部分
	if(X.Backtrack(stop+1))
	{
		for(int i=1; i<=n; i++)
		{
			cout<<p[i]<<" ";
		}
		found = true;
		cout<<endl;
	}
	
	delete []p;
	delete []q;
	return found;
}

int main()
{
	int n=8;  
    cout<<n<<"皇后问题的解为："<<endl;  
    while(!nQueen(n));  
    return 0;  
}
     程序运行结果如图：



灰太狼1号
关注
  • 1
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
拉斯维加斯算法
weixin_44737877的博客
12-12 4273
拉斯维加斯算法 通俗理解： 假如有一把锁，给我100把钥匙，只有1把是对的。于是我每次随机拿1把钥匙去试，打不开就再换1把。我试的次数越多，打开（最优解）的机会就越大，但在打开之前，那些错的钥匙都是没有用的。这个试钥匙的算法，就是拉斯维加斯算法. 拉斯维加斯算法就是每次采样尽量找最好的，但不保证能找到, 采样越多，越有机会找到最优解 蒙特卡洛和拉斯维加斯 这两类随机算法之间的选择，往往受到问...
n皇后问题
oct-month的博客
07-19 1061
n皇后问题 在 n×nn×nn×n 的国际象棋棋盘中放 nnn 个皇后，使得任意两个皇后都不能互相吃掉。规则是皇后能吃掉同一行、同一列、同一对角线的任意棋子。 模型建立 将 nnn 个皇后从 111 ~ nnn 编号，第 iii 个皇后的位置设定为第 iii 行，第 xix_ixi​ 列，坐标 (i,xi)(i, x_i)(i,xi​)。 要使得任意两个皇后都不能相互吃掉，那么 (1,x1)(1, x_1)(1,x1​)、(2,x2)(2, x_2)(2,x2​)、… 、(n,xn)(n, x_n)(
蒙特卡罗算法 与 拉斯维加斯算法
wudisunyanzi的专栏
01-19 8034
蒙特卡罗算法并不是一种算法的名称，而是对一类随机算法的特性的概括。媒体说“蒙特卡罗算法打败武宫正树”，这个说法就好比说“我被一只脊椎动物咬了”，是比较火星的。实际上是ZEN的算法具有蒙特卡罗特性，或者说它的算法属于一种蒙特卡罗算法。 那么“蒙特卡罗”是一种什么特性呢？我们知道，既然是随机算法，在采样不全时，通常不能保证找到最优解，只能说是尽量找。那么根据怎么个“尽量”法儿，我们我们把随机算法
7-4拉斯维加斯算法
我走的每一步都算数
12-25 263
拉斯维加斯
las.zip_LAS算法语义_Las Vegas
09-14
数据结构中的一种重要随机算法--Las Vegas算法,它总是给出正确的结果，但在少数应用中，可能出现求不出解的情况。也是用了50,500,5000子串验证的
稀疏非负卷积的确定性和拉斯维加斯算法_Deterministic and Las Vegas Algorithms for Sp
02-07
稀疏非负卷积的确定性和拉斯维加斯算法_Deterministic and Las Vegas Algorithms for Sparse Nonnegative Convolution.pdf
拉斯维加斯算法解决八皇后问题
10-10
自己根据拉斯维加斯算法，写的一个用来求解八皇后问题的python程序，其中可以自定义棋盘大小，显示程序的执行时间。
KMP, Monte Carlo 和Las Vegas算法程序类
09-04
这是东南大学计算机系数据结构（data structure）的KMP, Monte Carlo 和Las Vegas算法的程序类实现，里面有代码，报告。
KMP, Monte Carlo ，Las Vegas算法
09-04
这是本科算法（DS,DATA STRUCTURE）课程中中最重要的三种算法：KMP, Monte Carlo 和Las Vegas算法。资源里有做好的KMP, Monte Carlo 和Las Vegas算法代码以及2份算法报告。
拉斯维加斯法解n皇后问题
学者的博客
02-14 2984
问题提出 问题如下：有一个n×nn\times nn×n的棋盘，要求在上面放置n个皇后，这些皇后之间不能在一条直线或斜线上（45度），求一个符合要求的放置方案。 算法简介 拉斯维加斯算法随机产生一个解，但是这个解不一定符合题设要求（即拉斯维加斯算法可能找不到问题的解）。例如n皇后问题中，随机产生的摆放位置可能符合“n个皇后相互不在一条直线或斜线上”这一规则，也可能不符合。因此，可以通过循环调用此算...
拉斯维加斯（Las Vegas）算法
LiuHandsomes的博客
02-24 3639
前提： 拉斯维加斯属于概率算法的一种，那么对于概率算法就需要了解概率算法的特点和概率算法和确定性算法的区别。 我理解的概率算法和确定性算法的区别： 确定性算法对于每个输入实例的执行步骤，执行结果都是一定的。但概率算法是不定的。对于确定性算法有“平均执行时间”，对于概率算法有“期望执行时间”。 平均执行时间：输入规模一定的所有输入实例是等概率出现时，算法的平均执行时间。 期望执行时间：反复解同一个输入实例所花的平均时间。 概率算法的特点： 1.不可再现性：在同一个输入实例上，每次执行结果不尽相同
算法入门8：随机算法
JarvisChu的专栏
11-25 7690
之前将的算法都是确定的，即对于相同的输入总对应着相同的输出。但实际中也常常用到不确定的算法，比如随机数生成算法，算法的结果是不确定的，我们称这种算法为（随机）概率算法，分为如下四类： 数值概率算法         用于数值问题的求解，通常是近似解 蒙特卡洛算法Monte Carlo         能得到问题的一个解，但不一定是正确解，正确的概率依赖于算法运行的
算法设计与分析知识点整理
热门推荐
发光如星
01-02 1万+
本文是针对算法设计与分析这门课的知识点整理，内容多来源于教科书以及我看到的一些优秀博文，其中我最推崇是《labuladong的算法小抄》，它的内容让我眼前一亮，不同于教科书的死板套路，它从不一样的角度去解读学习算法，语言通俗易懂，让我受益匪浅。 我特别喜欢其中说的一句话 计算机解决问题其实没有任何奇技淫巧，它唯一的解决办法就是穷举，穷举所有可能性。算法设计无非就是先思考“如何穷举”，然后再追求“如何聪明地穷举”。
随机化算法的初步实践-N 后等问题
qq_61166620的博客
05-15 629
c++做随机化算法的初步实践-N 后等问题
拉斯维加斯算法与N皇后问题
wmx1117的博客
06-04 4553
随机化算法之拉斯维加斯算法 什么是随机化算法？ 就是是在算法中使用了随机函数，且随机函数的返回值直接或者间接的影响了算法的执行流程或执行结果。就是将算法的某一步或某几步置于运气的控制之下，即该算法在运行的过程中的某一步或某几步涉及一个随机决策，或者说其中的一个决策依赖于某种随机事件。 基本特征： 对所求解问题的同一实例用同一随机化算法求解两次可能得到完全不同的效果。 拉斯维加斯算法 拉斯维加斯算法不会得到不正确的解。一旦用拉斯维加斯算法找到一个解，这个解就一定是正确解。但有时用拉斯维加斯算法找不到解。与蒙特
利用概率算法求解N皇后问题
m0_48909881的博客
06-19 368
#include <stdio.h> #include <stdlib.h> #include <time.h> #include <assert.h> #define MAX 500 //利用概率算法求解八皇后问题 int check_pos(const int r[MAX],const int i,const int j); void print_pos(const int r[MAX],const int n); int queen_lv(int r[M
【高级算法】Lasvegas算法解决3SAT问题（C++实现代码）
牧之
06-12 3986
1、一个 SAT 问题是指: 对于给定的 CNF 是否存在一组关于命题变元的真值指派使得A 为真. 显然, 如果A 为真, 则 CNF 的每个子句中必有一个命题变元为 1 (真) 。 2、Las Vegas 算法是利用随机值做出随机选择的一种概率算法，并且不会产生不正确的答案。在计算过程中所做出的随机选择，可能使算法比其他算法更快地得到所要求的解。
python系统用拉斯维加斯算法解决N皇后问题
最新发布
05-19
N皇后问题是经典的回溯算法问题，而拉斯维加斯算法是一种随机化算法，它的特点是具有随机性和确定性的结合，可以在保证算法正确性的同时提高算法的效率。 下面是使用拉斯维加斯算法解决N皇后问题的Python代码： ``...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值