puzzle（0332）数字拼图旋转、九鼎之局、旋转数独

已于 2025-05-01 13:41:56 修改
阅读量3.2k 收藏 10
点赞数 3
文章标签： 游戏
于 2023-02-14 23:47:03 首次发布
-
本文链接：https://blog.csdn.net/nameofcsdn/article/details/129035547
版权

目录

一，数字拼图——旋转

1，手动求解

2，计算机求解

二，九鼎之局

三，旋转数独

1，规则

2，解法

3，轮换对称性

4，计算机求解

4.1已有代码

4.2 修改字符串输入方式、判定是否有解

4.3 求标准数独的9个九宫格的全排列空间的等价类个数。

4.4 遍历9个九宫格的位置

4.5 枚举9个九宫格的每种位置是否数独有解

4.6完整代码

一，数字拼图——旋转

数字华容道小游戏中的旋转模式

1，手动求解

很容易把第一行和第一列搞定，关键是右下角四个怎么排序。

出现这种情况，需要把5和6反过来。显然只要知道怎么交换5和6，就能轻松应付所有情况了。

经过几次尝试，我把公式找出来了，左上的旋转按钮是不需要的，所以我把其他三个按钮分别叫做上左右。

公式就是上上左上右上上右右左右右右左右右右，这17个操作下来，就把5和6对换了，其他的不动。

对于更高阶的情况，都可以直接化成3*3的情况，方法和数字拼图——滑动的方法一样。

2，计算机求解


void turn0(vector<int>&v)
{
    int x=v[0];
    v[0]=v[3],v[3]=v[4],v[4]=v[1],v[1]=x;
}
void turn1(vector<int>&v)
{
    int x=v[1];
    v[1]=v[4],v[4]=v[5],v[5]=v[2],v[2]=x;
}
void turn2(vector<int>&v)
{
    int x=v[3];
    v[3]=v[6],v[6]=v[7],v[7]=v[4],v[4]=x;
}
void turn3(vector<int>&v)
{
    int x=v[4];
    v[4]=v[7],v[7]=v[8],v[8]=v[5],v[5]=x;
}
void turn(int id,vector<int>&v)
{
    if(id==0)turn0(v);
    if(id==1)turn1(v);
    if(id==2)turn2(v);
    if(id==3)turn3(v);
}

vector<int> change56{1,1,2,1,3,1,1,3,3,2,3,3,3,2,3,3,3};

bool del3(vector<int>&v)
{
    if(v.size()<4)return false;
    for(int i=0;i+3<v.size();i++){
        if(v[i]==3 && v[i+1]==3 && v[i+2]==3 && v[i+3]==3){
            for(int j=i;j+4<v.size();j++)v[j]=v[j+4];
            v.resize(v.size()-4);
            return true;
        }
    }
    return false;
}

#define MOVE(id) opts.push_back(id),turn(id,v);
//输入123456789的排列，输出操作序列，0123分别是左上 右上 左下 右下
vector<int> solve33(vector<int>v)
{
    vector<int>opts;
    if(v[2]==1)MOVE(1);
    if(v[5]==1)MOVE(3);
    if(v[8]==1)MOVE(3);
    if(v[7]==1)MOVE(2);
    if(v[6]==1)MOVE(2);
    while(v[0]!=1)MOVE(0);
    if(v[6]==3)MOVE(2);
    if(v[3]==3)MOVE(2);
    if(v[8]==3)MOVE(3);
    if(v[7]==3)MOVE(3);
    while(v[1]!=3)MOVE(1);
    if(v[2]==2){
        MOVE(1);
        MOVE(1);
        MOVE(2);
        MOVE(2);
        MOVE(2);
        MOVE(1);
        MOVE(1);
        MOVE(2);
        MOVE(1);
    }else{
        if(v[6]==2)MOVE(2);
        if(v[3]==2)MOVE(2);
        while(v[4]!=2)MOVE(3);
        MOVE(1);
    }
    //至此是123******
    if(v[6]==4)MOVE(2);
    if(v[3]==4)MOVE(2);
    while(v[8]!=4)MOVE(3);
    if(v[5]==7){
        MOVE(3);
        MOVE(2);
        MOVE(3);
        MOVE(2);
    }else{
        while(v[3]!=7)MOVE(2);
        MOVE(3);
        MOVE(3);
        MOVE(2);
        MOVE(2);
        MOVE(2);
    }
    //至此是1234**7**
    while(v[4]!=5)MOVE(3);
    if(v[7]==6){
        MOVE(3);
        for(auto x:change56)MOVE(x);
    }
    if(v[8]==6){
        for(auto x:change56)MOVE(x);
        MOVE(3);
        MOVE(3);
        MOVE(3);
    }
    //至此是1234567**
    if(v[7]==9){
        MOVE(3);
        MOVE(3);
        for(auto x:change56)MOVE(x);
        MOVE(3);
        MOVE(3);
    }
    while(del3(opts));
    return opts;
}

二，九鼎之局

最强大脑同款项目。

就是数字拼图（旋转），使得每一行每一列都是9个不同的数字。

我的初始思路是贪心原则，一行行往下弄，最后只需要一个单独交换2个格子的公式即可。

但是也可能会变成这样：

右下角的9个无论怎么互换都不行了。

所以我的思路更新成，把右下角留出3个数，每个数3个。

即先按照贪心方法完成其他8个宫，最后一个宫是3个数各3个，就很容易完成，甚至不需要单独交换2格的公式。

  

最强大脑的同款项目中， 第一次达到榜一成就。

不过这个思路还是有一点偶然性，于是我把最强大脑选手的2个思路试了一下，即九宫格法和斜线法。

九宫格法：

斜线法：

这2个方法确实简单且高效，不会出现难搞的情况。 

三，旋转数独

最强大脑同款项目。

1，规则

使用四个旋转按钮和填充数字，使得变成一个完整的数独。

2，解法

（1）单个九宫格可以填充的数字就填充

这个case里面没有，那就跳过
（2）选择一个出现较多的数字，把它的9个位置都确定下来

这里的2就全部确定了
（3）选择一个数字较多的九宫格，确定和它在同一行的2个九宫格，把这3个九宫格都移到第一行

这里第一行的3个九宫格就确定在同一行了
（4）剩下的6个九宫格里面，再选择一个数字较多的九宫格，确定和它在同一行的2个九宫格，把这3个九宫格都移到第二行（第一行的3个九宫格位置不动）


这里的第二行的3个九宫格就确定在同一行了，那么第三行的3个九宫格也就确定在同一行了
（5）只根据行的信息和单个九宫格的信息，可以填充的数字就填充


这里的最右上角的九宫格就完成了
（6）第一行的3个九宫格位置固定不动，让第二行的3个九宫格之间互换，再让第三行的3个九宫格之间互换，使得数独有解

PS：同一行的3个九宫格之间如何交换，参考《数字拼图——旋转》里面的公式。


这里的9个九宫格位置就全部定下来了
（7）直接完成数独

直到这里，所有的数字都是确定的。

剩下的几个空格，不止一种填法，随便选择一种即可。

3，轮换对称性

我这个解法在2个地方都比较简洁，因为蕴含了轮换对称性。

参考我的轮换对称性总结：通用抽象概念

4，计算机求解

4.1已有代码

class DancingLink // 精确覆盖算法
class SearchWithGroupSum //分组数字搜索算法
string Sudoku(string s, char cEmpty = '.')

这2个类和1个函数的代码来自我的博客《十字交叉双向循环链表 dancing links》

因为输入的数独有可能是无解的，所以X算法要选V9拓展版。

4.2 修改字符串输入方式、判定是否有解

string Sudoku(vector<string>s,bool &flag)
{
    string ans;
    for(int i=0;i<9;i+=3){
        string s1=s[i],s2=s[i+1],s3=s[i+2];
        ans+=s1[0],ans+=s1[1],ans+=s1[2];
        ans+=s2[0],ans+=s2[1],ans+=s2[2];
        ans+=s3[0],ans+=s3[1],ans+=s3[2];
        ans+=s1[3],ans+=s1[4],ans+=s1[5];
        ans+=s2[3],ans+=s2[4],ans+=s2[5];
        ans+=s3[3],ans+=s3[4],ans+=s3[5];
        ans+=s1[6],ans+=s1[7],ans+=s1[8];
        ans+=s2[6],ans+=s2[7],ans+=s2[8];
        ans+=s3[6],ans+=s3[7],ans+=s3[8];
    }
    string ret = Sudoku(ans);
    flag = true;
    for(auto c:ret)if(c=='0')flag=false;    
    return ret;
}

把输入方式改成输入9个九宫格的字符串，出参flag表示是否有解。

4.3 求标准数独的9个九宫格的全排列空间的等价类个数。

求解：

（1）第一行第一个随便放，然后8个选2个放在第一行，顺序随意。C（8,1）*C（7,1）/2=28

（2）剩下6个分为2组，随便一组放第二行，另一组放第三行。C（6,3）*C（3,3）/2=10

（3）第二行排序，3！=6，第三行排序，3！=6

所以最终的等价类个数是28*10*6*6=10080

总结：

（1）9!是10080的36倍。实际上，每一个等价类都有36个对象，因为3行的排列有6种，3列的排列有6种，6*6=36。

（2）得到10080这个数字有2种方法，第一是C（8,1）*C（7,1）/2*C（6,3）*C（3,3）/2*3！*3！=10080，第二是9！/3!/3!=10080，虽然第二种更巧妙简单，但是第一种揭露了一个重要的细节，即如何进行DFS剪枝。

（3）不同剪枝方法的效率是不同的，上面的求解出10080的第一种方法，这是几乎是最优剪枝。因为10080个对象是必须要遍历的，而这里的方法基本上也就只遍历这10080个对象。不过我下面的编程实现，处于实现简单，遍历了10080*2个对象，性能也能接受。

4.4 遍历9个九宫格的位置

用123456789表示标准数独的9个九宫格，求10080个互不等价的对象。


//A66 / 2
vector<vector<int>> A66Div2(vector<int>v)
{
    int mins = v[0];
    for(auto x:v)mins=min(mins,x);
    vector<vector<int>>ans;
    for(int i=0;i<6;i++){
        for(int j=0;j<6;j++){
            if(j==i)continue;
            for(int k=0;k<6;k++){
                if(k==i || k==j)continue;
                if(v[i]!=mins && v[j]!=mins && v[k]!=mins)continue;
                for(int i2=0;i2<6;i2++){
                    if(i2==i||i2==j||i2==k)continue;
                    for(int j2=0;j2<6;j2++){
                        if(j2==i||j2==j||j2==k||j2==i2)continue;
                        for(int k2=0;k2<6;k2++){
                            if(k2==i||k2==j||k2==k||k2==i2||k2==j2)continue;
                            ans.push_back({v[i],v[j],v[k],v[i2],v[j2],v[k2]});
                        }
                    }
                }
            }
        }
    }
    return ans;
}
vector<vector<int>> solve()
{
    vector<vector<int>>ans;
    vector<int>v;
    v.resize(9);
    v[0]=1;
    for(int i=2;i<=9;i++){
        for(int j=i+1;j<=9;j++){//把i和j随意放，理解成左边放小的右边放大的
            v[1]=i,v[2]=j;
            //剩下的6个元素，其实就是6的全排列，去掉其中一半的排列即可。
            vector<int>v2;
            for(int k=2;k<=9;k++)if(k!=i&&k!=j)v2.push_back(k);
            vector<vector<int>>v3=A66Div2(v2);
            for(auto v4:v3){
                for(int i=3;i<9;i++)v[i]=v4[i-3];
                ans.push_back(v);
            }
        }
    }
    return ans;
}

测试代码：


void main()
{
    vector<vector<int>>ans = solve();
    cout<<ans.size()<<endl<<endl;
    for(auto v:ans){
        cout<<v[0]<<" "<<v[1]<<" "<<v[2]<<endl;
        cout<<v[3]<<" "<<v[4]<<" "<<v[5]<<endl;
        cout<<v[6]<<" "<<v[7]<<" "<<v[8]<<endl;
        cout<<endl;
    }
}

运行结果：

省略后面很多行。

4.5 枚举9个九宫格的每种位置是否数独有解


void printAns(vector<string>s,vector<int>v,string ans)
{
    for(auto i:v){
        cout<<s[i-1]<<endl;
    }
    cout<<ans;
}
void myMain()
{
    vector<vector<int>>ans = solve();
    vector<string>s{
        "...25..87",
        "7.46....5",
        ".5..7...9",
        "7..146.5.",
        "196348.72",
        "5...97...",
        "4276.581.",
        "98.74.2.6",
        "362..19.4"
    };
    bool flag;
    for(auto v:ans){
        vector<string>vs;
        for(int i=0;i<9;i++)vs.push_back(s[v[i]-1]);
        string ret = Sudoku(vs,flag);
        if(flag){
            printAns(s,v,ret);
            break;
        }
    }
}

代码里面的9个字符串，对应9个九宫格，需要手动填写到代码中。

可能会有多个解，我这里只求一个解。

4.6完整代码

#include <iostream>
#include <algorithm>
#include<climits> 
#include <vector>
#include <map>
using namespace std;

class DancingLink // 精确覆盖算法
{
public:
	DancingLink(int m, int n, int maxNum) //01矩阵的行、列、1的最大数量
	{
		this->m = m, this->n = n, maxNum += n + 1;
		rhead.resize(m + 1), nums.resize(n + 1);
		row.resize(maxNum), col.resize(maxNum);
		up.resize(maxNum), down.resize(maxNum), lef.resize(maxNum), rig.resize(maxNum);
		sc.resize(m), rows.resize(m);
		for (int i = 0; i <= n; i++)
		{
			up[i] = i, down[i] = i;
			lef[i] = i - 1, rig[i] = i + 1;
			row[i] = 0, col[i] = i, nums[i] = 0;
		}
		lef[0] = n, rig[n] = 0;
        nums[0] = INT_MAX/2;
		key = n;
		for (int i = 0; i <= m; i++)rhead[i] = 0;
	}
	void push(int r, int c)//新增坐标在(r,c)的一个节点
	{
		row[++key] = r, col[key] = c;
		up[key] = c, down[key] = down[c];
		up[down[c]] = key, down[c] = key;
		if (rhead[r] == 0)rhead[r] = lef[key] = rig[key] = key;
		else
		{
			lef[key] = rhead[r], rig[key] = rig[rhead[r]];
			lef[rig[rhead[r]]] = key, rig[rhead[r]] = key;
		}
		nums[c]++;
	}
	vector<vector<int>> getAllAns()
	{
		return dfs(false);
	}
	vector<int> getAnyAns()
	{
		auto v = dfs(true);
		if (v.size())return v[0];
		return vector<int>{};
	}
private:
	vector<vector<int>> dfs(bool onlyOne)
	{
		vector<vector<int>>ans;
		while (true) {
			if (rig[0] == 0) {
				rows.resize(rowsid);
				ans.push_back(rows);
				rows.resize(m);
				if (onlyOne)return ans;
			}
			int c = min_element(nums.begin() + 1, nums.end()) - nums.begin();
			if (rig[0] == 0)c = 0;
			del(c);
			while (true) {
				c = down[c];
				if (c > n)break;
				reback(col[c]);
				if (scid == 0)return ans;
				c = sc[--scid];
				rowsid--;
				for (int j = rig[c]; j != c; j = rig[j])reback(col[j]);
			}
			sc[scid++] = c;//记录选中id
			rows[rowsid++] = row[c];
			for (int j = rig[c]; j != c; j = rig[j])del(col[j]);
		}
		return ans;
	}
	inline void del(int c)//删除第c列的所有元素和他们所在行的所有元素
	{
		lef[rig[c]] = lef[c], rig[lef[c]] = rig[c];
		for (int i = down[c]; i != c; i = down[i])
			for (int j = rig[i]; j != i; j = rig[j])
				down[up[j]] = down[j], up[down[j]] = up[j], nums[col[j]]--;
		nums[c] = INT_MAX/2;
	}
	inline void reback(int c)//完全回退del操作
	{
		lef[rig[c]] = rig[lef[c]] = c, nums[c] = 0;
		for (int i = down[c]; i != c; i = down[i]) {
			for (int j = rig[i]; j != i; j = rig[j])
				down[up[j]] = up[down[j]] = j, nums[col[j]]++;
			nums[c]++;
		}
	}
private:
	int m, n, key;
	vector<int>row, col;//每个节点的行，列
	vector<int>rhead;//每行第一个节点的id
	vector<int>up, down, lef, rig;//每个节点上下左右的节点id
	vector<int>nums;//每一列的元素个数
	vector<int>sc;
	int scid = 0, rowsid = 0;
	vector<int>rows;//覆盖选中的行，值的范围是从1到m
};
class SearchWithGroupSum //分组数字搜索算法
{
public:
	SearchWithGroupSum(vector<vector<int>>& gridGroup, int row, int col, int low, int high) :gridGroup{ gridGroup },row { row }, col{ col },low{low},high{high}
	{
		anti.resize(row*col);
		grid.resize(row*col);
		for (int g = 0; g < gridGroup.size(); g++) {
			for (int i = 0; i < gridGroup[g].size(); i++)anti[gridGroup[g][i]].push_back(g);
			maxNum += gridGroup[g].size();
		}
	}
	void setGrid(vector<int>& grid)//除了已知数字之外都填0，有type=1的格子时需要调用本接口
	{
		this->grid = grid;
	}
	void setType(vector<int>& type)//有type=1或-1的格子时需要调用本接口
	{
		this->type = type;
	}
	vector<int> getAnyAns()
	{
		int m = 0;
		for (auto k : type) {
			if (k == 0)m += high - low + 1;
			else if (k == 1)m += 1;
		}
		int n = gridGroup.size()*(high - low + 1) + row * col;
		DancingLink d(m, n, (maxNum+row*col)*(high-low+1));
		int r = 0;
		map<int, int>mrow;
		mrow[0] = -1;
		for (int i = 0; i < row*col; i++) {
			if (type[i] == -1)continue;
			int lw = low, hh = high;
			if (type[i] == 1)lw = hh = grid[i];
			for (int x = lw; x <= hh; x++) {
				d.push(++r, i + 1);
				for (auto k : anti[i]) {
					d.push(r, k*(high - low + 1) + x - low + row * col + 1);
				}
				mrow[r] = i;
			}
		}
		
		vector<int> ans = d.getAnyAns();
		for (auto rowId : ans) {
			int id = mrow[rowId];
			grid[id] += type[id]?0:low;
			while (id == mrow[rowId - 1])rowId--, grid[id]++;
		}
		return grid;
	}
private:
	int row, col;//网格行列数
	int low, high;//每个格子填入数字的范围是[low,high],  限制一：low>0
	vector<int>type;//标识所有格子类型，0是需要填数字，1是已知数字，-1是无效格子
	vector<int>grid;//所有格子中的数字
	vector<vector<int>>gridGroup;//每一组有哪些格子
	vector<vector<int>>anti;//每个格子属于哪些组
	int maxNum = 1;
};
 
string Sudoku(string s, char cEmpty = '.')
{
	vector<vector<int>>gridGroup;
	vector<int>v;
	for (int i = 0; i < 9; i++) {
		v.clear();
		for (int j = 0; j < 9; j++)v.push_back(i * 9 + j);
		gridGroup.push_back(v);
		v.clear();
		for (int j = 0; j < 9; j++)v.push_back(j * 9 + i);
		gridGroup.push_back(v);
	}
	for (int i = 0; i < 3; i++)for (int j = 0; j < 3; j++) {
		v.clear();
		for (int r = i * 3; r < i * 3 + 3; r++)for (int c = j * 3; c < j * 3 + 3; c++)v.push_back(r * 9 + c);
		gridGroup.push_back(v);
	}
	SearchWithGroupSum opt(gridGroup, 9, 9, 1, 9);
	vector<int>grid(81);
	vector<int>type(81);
	for (int i = 0; i < 81; i++)if (s[i] != cEmpty)grid[i] = s[i] - '0', type[i] = 1;
	opt.setGrid(grid);
	opt.setType(type);
	v = opt.getAnyAns();
	string ans(81, '0');
	for (int i = 0; i < 81; i++)ans[i] = v[i] + '0';
	return ans;
}
string Sudoku(vector<string>s,bool &flag)
{
    string ans;
    for(int i=0;i<9;i+=3){
        string s1=s[i],s2=s[i+1],s3=s[i+2];
        ans+=s1[0],ans+=s1[1],ans+=s1[2];
        ans+=s2[0],ans+=s2[1],ans+=s2[2];
        ans+=s3[0],ans+=s3[1],ans+=s3[2];
        ans+=s1[3],ans+=s1[4],ans+=s1[5];
        ans+=s2[3],ans+=s2[4],ans+=s2[5];
        ans+=s3[3],ans+=s3[4],ans+=s3[5];
        ans+=s1[6],ans+=s1[7],ans+=s1[8];
        ans+=s2[6],ans+=s2[7],ans+=s2[8];
        ans+=s3[6],ans+=s3[7],ans+=s3[8];
    }
    string ret = Sudoku(ans);
    flag = true;
    for(auto c:ret)if(c=='0')flag=false;    
    return ret;
}


/*
（1）第一行第一个随便放，然后8个选2个放在第一行，顺序随意。C（8,1）*C（7,1）/2=28
（2）剩下6个分为2组，随便一组放第二行，另一组放第三行。C（6,3）*C（3,3）/2=10
（3）第二行排序，3！=6，第三行排序，3！=6
*/

//A66 / 2
vector<vector<int>> A66Div2(vector<int>v)
{
    int mins = v[0];
    for(auto x:v)mins=min(mins,x);
    vector<vector<int>>ans;
    for(int i=0;i<6;i++){
        for(int j=0;j<6;j++){
            if(j==i)continue;
            for(int k=0;k<6;k++){
                if(k==i || k==j)continue;
                if(v[i]!=mins && v[j]!=mins && v[k]!=mins)continue;
                for(int i2=0;i2<6;i2++){
                    if(i2==i||i2==j||i2==k)continue;
                    for(int j2=0;j2<6;j2++){
                        if(j2==i||j2==j||j2==k||j2==i2)continue;
                        for(int k2=0;k2<6;k2++){
                            if(k2==i||k2==j||k2==k||k2==i2||k2==j2)continue;
                            ans.push_back({v[i],v[j],v[k],v[i2],v[j2],v[k2]});
                        }
                    }
                }
            }
        }
    }
    return ans;
}
vector<vector<int>> solve()
{
    vector<vector<int>>ans;
    vector<int>v;
    v.resize(9);
    v[0]=1;
    for(int i=2;i<=9;i++){
        for(int j=i+1;j<=9;j++){//把i和j随意放，理解成左边放小的右边放大的
            v[1]=i,v[2]=j;
            //剩下的6个元素，其实就是6的全排列，去掉其中一半的排列即可。
            vector<int>v2;
            for(int k=2;k<=9;k++)if(k!=i&&k!=j)v2.push_back(k);
            vector<vector<int>>v3=A66Div2(v2);
            for(auto v4:v3){
                for(int i=3;i<9;i++)v[i]=v4[i-3];
                ans.push_back(v);
            }
        }
    }
    return ans;
}


void turn0(vector<int>&v)
{
    int x=v[0];
    v[0]=v[3],v[3]=v[4],v[4]=v[1],v[1]=x;
}
void turn1(vector<int>&v)
{
    int x=v[1];
    v[1]=v[4],v[4]=v[5],v[5]=v[2],v[2]=x;
}
void turn2(vector<int>&v)
{
    int x=v[3];
    v[3]=v[6],v[6]=v[7],v[7]=v[4],v[4]=x;
}
void turn3(vector<int>&v)
{
    int x=v[4];
    v[4]=v[7],v[7]=v[8],v[8]=v[5],v[5]=x;
}
void turn(int id,vector<int>&v)
{
    if(id==0)turn0(v);
    if(id==1)turn1(v);
    if(id==2)turn2(v);
    if(id==3)turn3(v);
}

vector<int> change56{1,1,2,1,3,1,1,3,3,2,3,3,3,2,3,3,3};

bool del3(vector<int>&v)
{
    if(v.size()<4)return false;
    for(int i=0;i+3<v.size();i++){
        if(v[i]==3 && v[i+1]==3 && v[i+2]==3 && v[i+3]==3){
            for(int j=i;j+4<v.size();j++)v[j]=v[j+4];
            v.resize(v.size()-4);
            return true;
        }
    }
    return false;
}

#define MOVE(id) opts.push_back(id),turn(id,v);
//输入123456789的排列，输出操作序列，0123分别是左上 右上 左下 右下
vector<int> solve33(vector<int>v)
{
    vector<int>opts;
    if(v[2]==1)MOVE(1);
    if(v[5]==1)MOVE(3);
    if(v[8]==1)MOVE(3);
    if(v[7]==1)MOVE(2);
    if(v[6]==1)MOVE(2);
    while(v[0]!=1)MOVE(0);
    if(v[6]==3)MOVE(2);
    if(v[3]==3)MOVE(2);
    if(v[8]==3)MOVE(3);
    if(v[7]==3)MOVE(3);
    while(v[1]!=3)MOVE(1);
    if(v[2]==2){
        MOVE(1);
        MOVE(1);
        MOVE(2);
        MOVE(2);
        MOVE(2);
        MOVE(1);
        MOVE(1);
        MOVE(2);
        MOVE(1);
    }else{
        if(v[6]==2)MOVE(2);
        if(v[3]==2)MOVE(2);
        while(v[4]!=2)MOVE(3);
        MOVE(1);
    }
    //至此是123******
    if(v[6]==4)MOVE(2);
    if(v[3]==4)MOVE(2);
    while(v[8]!=4)MOVE(3);
    if(v[5]==7){
        MOVE(3);
        MOVE(2);
        MOVE(3);
        MOVE(2);
    }else{
        while(v[3]!=7)MOVE(2);
        MOVE(3);
        MOVE(3);
        MOVE(2);
        MOVE(2);
        MOVE(2);
    }
    //至此是1234**7**
    while(v[4]!=5)MOVE(3);
    if(v[7]==6){
        MOVE(3);
        for(auto x:change56)MOVE(x);
    }
    if(v[8]==6){
        for(auto x:change56)MOVE(x);
        MOVE(3);
        MOVE(3);
        MOVE(3);
    }
    //至此是1234567**
    if(v[7]==9){
        MOVE(3);
        MOVE(3);
        for(auto x:change56)MOVE(x);
        MOVE(3);
        MOVE(3);
    }
    while(del3(opts));
    return opts;
}

void printAns(vector<string>s,vector<int>v,string ans)
{
    vector<int>x;
    x.resize(9);
    int num=0;
    for(auto i:v){
        cout<<s[i-1]<<endl;
        x[i-1]=++num;
    }
    auto opts = solve33(x);
    for(auto opt:opts)cout<<opt<<" ";
    cout<<endl;
    for(int i=0;i<81;i++){
        cout<<ans[i];
        if(i%9==8)cout<<endl;
    }
}

void myMain()
{
    vector<vector<int>>ans = solve();
    string ss = "37..5827.264..11955.1.2.8..12.4.6.154...2..466.7..7.3.96.514....5..8.27..843..138";
    string s1,s2,s3,s4,s5,s6,s7,s8,s9;
    s1=s1+ss[0]+ss[1]+ss[2]+ss[9]+ss[10]+ss[11]+ss[18]+ss[19]+ss[20];
    s2=s2+ss[3]+ss[4]+ss[5]+ss[12]+ss[13]+ss[14]+ss[21]+ss[22]+ss[23];
    s3=s3+ss[6]+ss[7]+ss[8]+ss[15]+ss[16]+ss[17]+ss[24]+ss[25]+ss[26];
    s4=s4+ss[27]+ss[28]+ss[29]+ss[36]+ss[37]+ss[38]+ss[45]+ss[46]+ss[47];
    s5=s5+ss[30]+ss[31]+ss[32]+ss[39]+ss[40]+ss[41]+ss[48]+ss[49]+ss[50];
    s6=s6+ss[33]+ss[34]+ss[35]+ss[42]+ss[43]+ss[44]+ss[51]+ss[52]+ss[53];
    s7=s7+ss[54]+ss[55]+ss[56]+ss[63]+ss[64]+ss[65]+ss[72]+ss[73]+ss[74];
    s8=s8+ss[57]+ss[58]+ss[59]+ss[66]+ss[67]+ss[68]+ss[75]+ss[76]+ss[77];
    s9=s9+ss[60]+ss[61]+ss[62]+ss[69]+ss[70]+ss[71]+ss[78]+ss[79]+ss[80];
    vector<string>s{
        s1,s2,s3,s4,s5,s6,s7,s8,s9
    };
    bool flag;
    for(auto v:ans){
        vector<string>vs;
        for(int i=0;i<9;i++)vs.push_back(s[v[i]-1]);
        string ret = Sudoku(vs,flag);
        if(flag){
            printAns(s,v,ret);
            break;
        }
    }
}

int main() {
    myMain();
	return 0;
}

其中，string ss = "37..5827.264..11955.1.2.8..12.4.6.154...2..466.7..7.3.96.514....5..8.27..843..138";  这一行需要每次手动更新，其他代码不用动。

csuzhucong
关注
iOS 滑块拼图游戏（Puzzle8）
findhappy117的博客
03-04 984
代码地址如下：http://www.demodashi.com/demo/11505.html 一、准备工作 先了解一个定义和定理 定义：在一个1,2,…,n的排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序。一个排列中逆序的总数就称为这个排列的逆序数。逆序数为偶数的排列称为偶排列；逆序数为奇数的排列称为奇排列。如2431中，21，43，41，31是逆序
九宫格旋转问题。
weixin_30467087的博客
01-28 671
手动测试页面：http://coolpeng.duapp.com/test/temp1/test.html 程序实现方案 九宫格的每一个状态，都可以看做是图中的一个节点。总共有9*8*7*6*5*4*3*2*1=362880个节点每个节点周围都有八个路径可以选择。这样就变成了一个无向图然后，使用广度优先遍...
puzzle拼图游戏
10-16
简单的puzzle拼图游戏，使用原生JavaScript编写，简单易懂。
Puzzle Game拼图游戏
weixin_30248399的博客
05-26 135
这是我自己开发的一个小游戏，菜鸟一个，还请大家多多指教！/Files/pipiguagua/PuzzleGame.7z 转载于:https://www.cnblogs.com/wander1128/archive/2009/05/26/1490401.html
Android群英传-拼图游戏puzzle-代码设计和实现
weixin_30815427的博客
12-05 222
上个周末，3个小时总体上读完了《Android群英传》，本周主要在研究代码层次的设计和实现。 编译安装在手机上，玩了几把，结合代码，一周时间才掌握了整体的思路。 大部分时间，其实花在了“重构”上。 重构的过程，就是学习和思考的过程。 本文，算是一篇学习总结，总体介绍下这款小游戏的实现思路。 后面抽空，再改造下这个游戏不合理的设计方式，即格子是N*N+1，而不是N*N个。...
深入解析 Puzzle：一个创新的开源拼图游戏开发框架
gitblog_00055的博客
04-23 741
深入解析 Puzzle：一个创新的开源拼图游戏开发框架 项目地址:https://gitcode.com/gh_mirrors/puzz/puzzle 项目简介 是一款基于 JavaScript 的开源拼图游戏框架，由开发者 szisa 创作并维护。它允许你轻松地构建具有各种难度级别的拼图游戏，而且可以根据需要自定义图形和交互逻辑，为教育、娱乐或个性化应用提供了强大的工具。 技术分析 核心特性 ...
MATLAB小游戏拼图-puzzle.zip
08-13
MATLAB小游戏拼图-puzzle.zip 近期刚学GUI，然后用拼图游戏来练练手，给需要学习GUI的人分享一下。 界面包括一个菜单项，可以选择难度：easy,midium,hard，对应拼图为3*3、4*4和5*5； 工具栏有4个按钮，分别为载入内置图片、读取外部图片文件、开始游戏和查看原图像。 游戏规则： 通过控制‘上’、‘下’、‘左’、‘右’4个键来移动图片，当图片复原时则游戏成功。 运行： 直接解压运行main.m文件即可。 ps.如果要读取图片文件的话，图片长宽比尽量一致，否则会失真比较严重。
VB.rar_VB拼图_puzzle_vb 拼图游戏_拼图
09-23
【VB.rar】是一个包含VB（Visual Basic）编程语言开发的拼图游戏的资源包，名为“VB拼图_puzzle_vb”。这个项目旨在为初学者提供一个实践平台，让他们了解和学习VB的基础知识以及如何利用它来创建交互式应用程序。 ...
block puzzle jewel 方块拼图消除游戏安卓源码
01-13
"Block Puzzle Jewel"是一款基于Android平台的方块拼图消除游戏，它的源码为我们提供了深入理解游戏开发，尤其是休闲益智类游戏开发的机会。这款游戏中，玩家需要将各种形状的方块拖放到游戏板上，当某行或某列填满...
Creep 2 Puzzle 讨厌鬼拼图
最新发布
11-27
Creep 2 Puzzle，一款与“讨厌鬼”主题相关的益智游戏，以其独特的拼图方式吸引玩家。游戏的模型文件包含在提供的压缩包内，玩家可以通过这些文件深入理解游戏的构造和设计。游戏的内容描述和标签强调了其主要特色...
15puzzle:这是一个基于15puzzle的数字与拼图版游戏
05-15
这是一个基于15puzzle的数字与拼图版游戏 ————此游戏是根据经典的15数码难题开发的，随着阶数的增加，游戏难度会大幅增加。 此外，本游戏加入了图片模式，您还可以自定义图片，这可跟普通的拼图有较大的区别哦。...
网页版数字华容道，非常简单
11-28
网页版数字华容道，非常简单
jQuery实现数字华容道小游戏(实例代码)
10-15
主要介绍了jQuery实现数字华容道小游戏功能，本文给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
Puzzle for 3dMax拼图随机生成器工具下载
02-25
3DMAX拼图随机生成器（英文：Puzzle），是一款为3dsMax开发的拼图建模小工具，可以随机创建可编辑多边形3D拼图对象。可批量生成阵列。 安装方法：点击3dmax主菜单-脚本-运行脚本，选择Puzzle-1.0.0-zh_CN运行即可。
拼图游戏思路
xinsong520的博客
08-28 2088
1.添加一个图片元素 2.设置2个变量，决定对图片横向和纵向进行切割的块数。 3.切割图片完成后，将分割的图片放入图形数组。点击打乱按钮，随机顺序按矩形（cc.rect）把图片放到场景中。并把右下角的一个色块透明度设置为0,显示为不可见。 4.图形数组初始化，用一个数组储存图片没有被随机打乱时的下标。 5.通过点击不可见色块周围的色块可实现与不可见色块的交换。数字矩阵值和图片互换，一直到全
电子拼图思维逻辑机的破解思路
kissmeprettygirl的专栏
11-17 2361
给孩子买了一个电子拼图思维逻辑机的玩具，通过算法解决了游戏的解法，但是一旦跑了代码，这个玩具也就失去了本身的意义，且行且珍惜
puzzle（0334）色块拼图、物换星移、魔轮、移星掠形
nameofcsdn的博客
02-03 1753
。。。
【Cocos Creator 实战】05 - 如何判断拼图完成（胜利）
热门推荐
Bottle's Blog
09-20 5万+
文章目录概览主要内容项目资源开搞胜利规则核心代码总结知识点下一步 继续继续。 上一篇地址：【Cocos Creator 实战】04 - 如何给拼图加上吸附效果 概览 主要内容 来看看今天要做的内容： 如何判断拼图游戏已经结束（胜利） 来看看将要实现的效果： 项目资源 项目地址：https://github.com/BottleMan/Bottle-s-Jigsaw/tree/05_chec...
小游戏与数学
zashizhi3299的博客
04-07 397
华容道”来自于经典的三国故事，在赤壁之战中，曹操被打败被迫逃到了华容道，差点就被诸葛亮拿下。而关羽为了报答曹操，明里相逼，暗里相让，最终帮曹操逃出天罗地网。后来经过演变，就有了滑块华容道、数字华容道，甚至推箱子游戏。数字华容道：利用1个空格，把数字按顺序重新排列。滑块华容道：利用1个空格，把图片恢复原样。？
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值