排列宝石问题 回溯

问题描述:

现有n种不同形状的宝石,每种n 颗,共n*n颗。同一种形状的n颗宝石分别具有n种不同的颜色c1,c2,…,cn中的一种 颜色。欲将这n*n颗宝石排列成n行n列的一个方阵,使方阵中每一行和每一列的宝石都有n种不同形状和n种不同颜 色。

试设计一个算法,计算出对于给定的n,有多少种不同的宝石排列方案。  

算法设计:

对于给定的n,计算出不同的宝石排列方案数。 

 

输入文件示例    输出文件示例

       1                             1 


#include <stdio.h>
#define N 9
int shape[N][N];//棋盘记录石子的形状
int color[N][N];//记录棋盘石子的颜色
bool stone[N][N];//stone[i][j]表示i形状的j颜色的石子是否已经用过
int cnt = 0;
int n = 0;
//row行,col列
bool isOK(int row,int col)
{
if(stone[shape[row][col]][color[row][col]])
{
   //如果石子没有被用过
   //检查这一行
   for(int i=1;i<col;i++)
   {
    if(shape[row][i]==shape[row][col] || color[row][i]==color[row][col])
    {
     return false; 
    }
   }
   //检查这一列
   for(int j=1;j<row;j++)
   {
    if(shape[j][col]==shape[row][col] || color[j][col]==color[row][col])
    {
     return false; 
    }
   }
   return true;
}
else
{
   //如果石子已经被用过
   return false;
}
}
void Swap(int &x,int &y)
{
int tmp = x;
x = y;
y = tmp;
}
//从上到下,从左到右回溯,row代表行,col代表列
void BackTrace(int row,int col)
{
if(row>n)
{
   //排完了最后一行
   cnt++;
   return ;
}
else if(col>n)
{
   //一行排序完毕,排序下一行
   BackTrace(row+1,1);
}
else
{
   for(int i=col;i<=n;i++)
   {
    //排列形状
    Swap(shape[row][col],shape[row][i]);
    for(int j=col;j<=n;j++)
    {
     //排列颜色
     Swap(color[row][col],color[row][j]);
     if(isOK(row,col))
     {
      stone[shape[row][col]][color[row][col]] = false;
      BackTrace(row,col+1);
      stone[shape[row][col]][color[row][col]] = true;
     }
     Swap(color[row][col],color[row][j]);
    }
    Swap(shape[row][col],shape[row][i]);
   }
}

}

int main()
{
while(scanf("%d",&n)!=EOF)
{
   //初始化工作
   cnt = 0;
   for(int i=1;i<=n;i++)
   {
    for(int j=1;j<=n;j++)
    {
     color[i][j] = j;
     shape[i][j] = j;
     stone[i][j] = true;
    }
   }
   BackTrace(1,1);
   printf("%d\n",cnt);
}
return 0;
}


  • 4
    点赞
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
旅行商问题是一个经典的NP完全问题,可以使用排列树和回溯法来求解。下面是使用C++实现的代码: ```c++ #include <iostream> #include <cstring> #include <algorithm> using namespace std; const int N = 10; // 城市数量 int g[N][N]; // 城市间的距离 bool st[N]; // 标记城市是否被访问过 int path[N]; // 存储路径 int bestPath[N]; // 存储最优路径 int dist; // 存储当前路径长度 int bestDist = 0x3f3f3f3f; // 存储最优路径长度 void dfs(int u, int depth) { if (depth == N) { // 访问完所有城市 if (dist + g[u][0] < bestDist) { // 如果当前路径更优 bestDist = dist + g[u][0]; // 更新最优路径长度 for (int i = 0; i < N; i++) bestPath[i] = path[i]; // 更新最优路径 } return; } for (int i = 1; i < N; i++) { if (!st[i]) { // 如果城市未访问过 st[i] = true; // 标记为访问过 dist += g[u][i]; // 更新路径长度 path[depth] = i; // 存储路径 dfs(i, depth + 1); // 递归访问下一个城市 dist -= g[u][i]; // 恢复路径长度 st[i] = false; // 标记为未访问过 } } } int main() { // 输入城市间的距离 for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { cin >> g[i][j]; } } // 从第一个城市开始遍历 st[0] = true; path[0] = 0; dfs(0, 1); // 输出最优路径 for (int i = 0; i < N; i++) { cout << bestPath[i] << " "; } cout << endl; // 输出最优路径长度 cout << bestDist << endl; return 0; } ``` 在上述代码中,我们使用了一个二维数组 `g` 存储城市间的距离,一个布尔数组 `st` 标记城市是否被访问过,一个一维数组 `path` 存储当前路径,一个一维数组 `bestPath` 存储最优路径,一个变量 `dist` 存储当前路径长度,一个变量 `bestDist` 存储最优路径长度。 我们从第一个城市开始遍历,递归地访问下一个城市,直到访问完所有城市。在访问每个城市时,我们需要判断该城市是否被访问过,如果未访问过,则将其标记为访问过,并更新路径长度和路径。在访问完所有城市后,我们需要判断当前路径是否更优,并更新最优路径和最优路径长度。最后,输出最优路径和最优路径长度即可。 需要注意的是,排列树和回溯法的时间复杂度都为 $O(n!)$,因此在城市数量较大时,算法的效率会非常低。可以使用其他算法,如动态规划、遗传算法等来求解旅行商问题

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值