重排算法

㈠ 求重排九宫的算法

我现在的想法就是开一个9 * 9 * 9 * 9 * 9 * 9 * 9 * 9 * 9的数组保存状态，进行基于状态的宽度优先搜索，每次相当于移动空格，我再想想吧。。。

㈡ 写出按从大到小的顺序重新排列x，y，z三个数值的算法。 注意，是算法！

你说的是C语言吗?
首先初始状态是xyz
①、比较第一和第二个数，如果第一个小，不作处理，然后执行步骤②；如果第二个小，将两者位置交换，然后执行步骤②
②、比较第二和第三个数，如果第二个小，不作处理，并结束排序；如果第三个小，将两者位置交换，然后执行步骤③
③、比较第一和第二个数，如果第一个小，不作处理，并结束排序；如果第二个小，将两者位置交换，并结束处理

㈢ 对任一自然数重排数字使之最大算法的设计与实现

#include <stdio.h>
#define N 10
main()
{
long x,y;
int a[N],i,j,n,t;
printf("x=");
scanf("%d",&x);
n=0;
do
{ y=x%10;
a[n++]=x%10;
x=x/10;
}while(x!=0);
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(a[i]<a[j])
{ t=a[i];a[i]=a[j];a[j]=t;}
y=0;
for(i=0;i<n;i++)
y=10*y+a[i];
printf("Max=%d\n",y);
}

㈣ C++编程,用A*算法重排九宫图

昏, 那个不叫九宫图吧, 那个是螺旋矩阵, 比九宫图简单多了:

#include <iostream>
#include <cstring>
using namespace std;

const int size = 200;
int iM2Dimen[size][size];

#define M iM2Dimen

int Digit(int n)
{
int x = 0;

do{
++x;
n /= 10;
}while(n != 0);

return x;
}

void Print(int n)
{
int width = Digit(n*n);
for(int i = 0; i < n; ++i)
{
for(int j = 0; j < n; ++j)
{
cout.width(width);
cout << M[i][j] << ' ';
}
cout << endl;
}
}

void Helix(int n)
{
memset(M, 0, sizeof M);
int iR = -1, iC = -1;
int x = n;

// 把i <= n*n 改成i < n*n 看看
for(int i = 1, j = 0; i <= n*n; ++i)
{
for(++iR, ++iC, j = 0; j < x; ++iC, ++i, ++j)
M[iR][iC] = i;
if(i > n*n)break;
--x;

for(--iC, ++iR, j = 0; j < x; ++iR, ++i, ++j)
M[iR][iC] = i;
if(i > n*n)break;

for(--iR, --iC, j = 0; j < x; --iC, ++i, ++j)
M[iR][iC] = i;
if(i > n*n)break;
--x;

for(++iC, --iR, j = 0; j < x; --iR, ++i, ++j)
M[iR][iC] = i;
if(i > n*n)break;
--i;
}
Print(n);
}

int main()
{
Helix(3);
cout << endl;
Helix(4);
cout << endl;
Helix(5);
cout << endl;
}

测试结果:

1 2 3
8 9 4
7 6 5

1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7

1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

㈤ 重排九宫问题算法

㈥ 关于排列组合中的重排问题冥算法的疑问。

最后那3个中。
“第一个发给了A单位，第二三个全是B单位。”
和“第一二个发给了B单位，第三个发给了C单位。”
在你的27种里是占了2种情况的，但对题目“多少种发法”来说就是同一种情况。
他问的发法是只要结果相同就是同一种，并不在乎你是先给谁发后给谁发。因为你发的材料是相同的。

而实习生人与人是不同的，应此可以套用N次方分步的算法。

㈦ 在线等重排九宫图算法，50分

首先在整个矩阵的最下面一行的中央置1，
然后向右下方向顺序填上2,3,4,5,6,7,……
注意碰到底的时候就将数翻到上面去，碰到右边的时候就翻到左面去
比如5*5的幻方，如果1填在(5,3)处，2就应该填在（1,4）处，4就应该填在（3,1）处……
另外，当原数的下方已经有数时，要将要填入的数填到原数正上方
仍举5*5幻方的例子，当5已填好（4，2）时，其右下方为1，不能把6填在那里，而应填在（3,2）处，即5的上方。
最后，一个特殊的点，右下角，这时也应当将新数填在右下角的上方。
下面给出5*5的幻方的一个解：
11 18 25 2 9
10 12 19 21 3
4 6 13 20 22
23 5 7 14 16
17 24 1 8 15

#include<stdio.h>
#include<ctype.h>
#define MAX 10

int a[MAX][MAX]={0};
int N=0;

void initial()
{
int i,j;
for(i=0;i<MAX;i++)
for(j=0;j<MAX;j++)
{
a[i][j]=0;
}
}

void get()
{
int i=0,j;
int pre_i,pre_j;
int k=1;
a[0][N/2]=k;
i=0;
j=N/2;
for(k=2;k<=N*N;k++)
{
pre_i=i;
pre_j=j;
i--;
j++;
if(pre_i==0)
{
i=N-1;
}
if(pre_j==N-1)
{
j=0;
}

if(a[i][j]!=0)
{
i=pre_i;
j=pre_j+1;
a[i][j]=k;
}
if(a[i][j]==0)
{
a[i][j]=k;
}
}
}

main()
{
int i,j;
char flag=-1;
while(1)
{
initial();
printf("please input the square of the matrix:\n");
scanf("%d",&N);
fflush(stdin);
get();
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
printf("%d",a[i][j]);
printf("\t");
}
printf("\n");
}
printf("do you want to continue?[Y\N]\n");
scanf("%c",&flag);
fflush(stdin);
if(flag=='N'||flag=='n')
break;
}
}

㈧ C语言怎么位数重排

2进制转化为16进制时，先把2进制写成一排，然后从低位往高位数，每四位分为一段，一段组成以为十六进制，高位不够四位后，从左边补0

㈨ 重排九宫问题（用java实现）

import java.util.Arrays;
public class NineGridTest{
public static void main(String[] args){
//三行数据依次排列9个元素构造实例，空位填0，调用go方法获取答案。
NineGrid example=new NineGrid(new int[]{1,6,5,3,0,2,7,8,4});
int[] answer=example.go();
if(answer==null){
System.out.println("没有找到步骤");
}
else{
for(int i=0;i<answer.length;i++){
System.out.print(answer[i]);
}
System.out.println();
}
}
}
class NineGrid{
private static final int MAX_STEP=50;
private static final int[] right=new int[]{1,2,3,8,0,4,7,6,5};
private int vacant,length;
private int[] grids,answer;
public NineGrid(int[] grids){
if(grids.length!=9){
throw new IllegalArgumentException(String.format("缺少数据：%1$d(%2$d)",grids.length,9));
}
int i,j;
for(i=8;i>=0;i--){
for(j=0;j<9;j++){
if(grids[j]==i){
break;
}
}
if(j==9){
throw new IllegalArgumentException("无效的数字序列。缺少："+i);
}
}
this.grids=grids;
answer=new int[50];
length=0;
}
public int[] go(){
for(vacant=0;vacant<9&&grids[vacant]!=0;vacant++);
return nextStep(0)?Arrays.Of(answer,length):null;
}
private boolean OK(){
return Arrays.equals(grids,right);
}
private boolean nextStep(int step){
if(step==MAX_STEP){
return false;
}
int[] siblings=getSiblings(vacant);
for(int i=0;i<siblings.length;i++){
if(step>0&&grids[siblings[i]]==answer[step-1]){
continue;
}
grids[vacant]=grids[siblings[i]];
answer[step]=grids[vacant];
grids[siblings[i]]=0;
vacant^=siblings[i];
siblings[i]^=vacant;
vacant^=siblings[i];
if(OK()){
length=step+1;
return true;
}
else{
boolean result=nextStep(step+1);
if(result){
return true;
}
else{
grids[vacant]=grids[siblings[i]];
vacant=siblings[i];
grids[vacant]=0;
}
}
}
return false;
}
private int[] getSiblings(int position){
switch(position){
case 0:return new int[]{1,3};
case 1:return new int[]{0,2,4};
case 2:return new int[]{1,5};
case 3:return new int[]{0,4,6};
case 4:return new int[]{1,3,5,7};
case 5:return new int[]{2,4,8};
case 6:return new int[]{3,7};
case 7:return new int[]{4,6,8};
case 8:return new int[]{5,7};
default:return null;
}
}
}
//递归算法。超慢。。。。

㈩ 试写出一个将已知字符串所有字符倒过来重新排列的算法。如ABCDEF改为FEDCBA

#include <stdio.h>
#include <string.h>
main()
{
void change(char *p);//声明函数，定义变量、指针
char str[50];
char *p1;
puts("input a string:");//输入一个串
gets(str);
p1=str;
change(p1);//调用函数
puts(str);
}
void change(char *p)
{
int i;
char *p_f,*p_e;
char temp;
i=strlen(p);
p_f=p;p_e=p+i-1;//串的首地址和尾地址
while(p_f<p_e)//头的第一个和尾的最后一个换
{
temp=*p_f;
*p_f=*p_e;
*p_e=temp;
p_f++;p_e--;
}
}