// Bigger Square Please... (拼接正方形)
// PC/UVa IDs: 110808/10270, Popularity: C, Success rate: high Level: 3
// Verdict: Accepted
// Submission Date: 2011-09-25
// UVa Run Time: 0.032s
//
// 版权所有(C)2011,邱秋。metaphysis # yeah dot net
//
// [问题描述]
// Tony 有很多张正方形纸片。这些纸片的边长为 1 到 N - 1 不等,且每种纸片都有无数张。但是他并不
// 满足。他想要一张更大的 ---- 边长为 N 的纸片。
//
// 可以把已有纸片拼接成他想要的大正方形。例如,一个边长为 7 的正方形可以通过如下 9 个更小的正方形
// 拼接而成(使用字母来填充相应的正方形,A 表示边长为 1 的正方形纸片,B 表示边长为 2 的正方形纸
// 片,依此类推):
//
// B B B B C C C
// B B B B C C C
// A B B A C C C
// A B B D D D D
// C C C D D D D
// C C C D D D D
// C C C D D D D
//
// 在拼接出的正方形中间不能有空隙,不能有纸片超出正方形,且纸片不能相互重叠。并且,Tony 想要用尽
// 可能少的纸片来拼出这个大的正方形。你能帮助他吗?
//
// [输入]
// 输入第一行有一个单独的整数 T,表示测试数据的组数。每组数据为一个单独的整数 N(2 <= N <= 50)。
//
// [输出]
// 对于每组数据,输出一行,包含一个整数 K,表示最少需要的纸片数。接下来 K 行,每行三个整数 x,y,
// l,表示纸片左上角的坐标 (1 <= x,y <= N) 以及纸片的边长。
//
// [样例输入]
// 3
// 4
// 3
// 7
//
// [样例输出]
// 4
// 1 1 2
// 1 3 2
// 3 1 2
// 3 3 2
// 6
// 1 1 2
// 1 3 1
// 2 3 1
// 3 1 1
// 3 2 1
// 3 3 1
// 9
// 1 1 2
// 1 3 2
// 3 1 1
// 4 1 1
// 3 2 2
// 5 1 3
// 4 4 4
// 1 5 3
// 3 4 1
//
// [解题方法]
// 该题是 UVa 上的所有题目中 10% 较难的题目中的一题。如果是实时产生拼接方案,而不是预先生成拼接
// 方案再提交,说明水平确实比较高。题目要求用边长为 1 - (N - 1) 的任意张纸片拼接成一个边长为
// N 的正方形纸片,纸片间互相不能重叠,且不能超出边长为 N 的正方形范围,求使用纸片数最少的拼接方
// 案,以左上角为坐标起点 (1,1),按坐标、纸张边长的顺序输出每张纸片的坐标、边长值。
//
// 根据题意,设需要拼接的正方形边长为 N,很明显,拼接方案是一系列平方数的和。问题转化为如何将 N 表
// 示为平方数之和,且要求平方数的个数最小,这个问题可以通过回溯来解决。但是得到了一个将 N 拆分为平
// 方数之和的方案,并不表示就能将这些大小的纸片拼接成一个边长为 N 的纸片,例如,对于 N = 5,可以
// 拆分为 9 与 16 的和,9 和 16 都是平方数,但是实际上无法将一张边长为 3 和一张边长为 4 的纸片
// 拼接为一张边长为 5 的纸片,所以在生成一个平方数和方案后,需要实际尝试放置,若能放置,则表明此方
// 案可行,予以记录,将所有可行的方案记录后,挑选其中纸片数最小的方案即为所求。这样的话,将 N 拆分
// 为平方数之和是一步回溯,将拆分方案尝试放置又是一步回溯,需要通过两步回溯来解决本问题。
//
// 考虑到需要两步回溯,如果不予以充分剪枝,则计算时间将不可忍受,在 UVa BBS 上关于这个题目的讨论
// 即反映了这种情况。在将 N 拆分为平方数和的一步,若能生成一个拆分方案,尽管不是最优的,但是它的总
// 个数较小,且能实际放置,则将此方案的总个数作为剪枝阈值将可避免较多无效的搜索,将 N 拆分为平方数
// 后且能实际放置的一个非最优方案可以这样构造:左上角放置一个边长为 (N - 2) 的纸片,然后在右侧和
// 下方放置边长为 2 的纸片,剩余的空间放置边长为 1 的纸片,这样总的纸片需要数量为: 1 + [N / 2]
// + [(N - 2) / 2] + 4,其中符号 [] 表示取整,这样总的纸片放置数在 N 附近,可以做为一个较好
// 的剪枝阈值。通过回溯发现了总个数更少的方案后,则开始尝试实际放置,可以通过设立一个网格数组,当
// 填充边长为 A 的纸片时,在网格中查找是否有起始坐标为 (x,y) 且边长为 A 的空白区域,若无此种
// 空白区域,则表明该方案无法实际放置,若能找到,则找到所有这样的起始位置,逐一回溯进行尝试,尝试
// 某位置后,则将该区域标记为已填充,若后继填充不成功返回时则撤销标记。对于已经产生但不能实际拼接
// 的拆分方案需要予以记录,在后继生成的方案中,若有方案与记录的方案相同,则不必再次浪费时间搜索。
//
// 通过网络搜索该问题的相关信息可以知道,当 N MOD 2 = 0 或者 N MOD 6 = 3 时,有特殊的解法。
// 对于 N MOD 2 = 0,即 N 为偶数时,最少纸片数的拼接方法为:用 4 张边长为 N / 2 的纸片拼接得
// 到边长为 N 的正方形。当 N MOD 6 = 3 时,放置方法与 N = 3 的方案类似,只不过将相应的纸片边长
// 增加同样的数量。同时平方数如 25 的拼接方案和 5 的拼接方案类似,49 的拼接方案和 7 的拼接方案
// 类似,则在 2 - 50 之间的数,只需要求出质数的拼接方法即可。网络上已经有 2 - 50 之间的质数的
// 拼接方案和最少需要纸片数,利用这些信息,可以显著减少计算时间,甚至直接生成拼接方案后再提交。
//
// 参考网页:
// http://www2.stetson.edu/~efriedma/mathmagic/1298.html
// http://mathpuzzle.com/perkinsbestquilts.txt
// http://mathworld.wolfram.com/MrsPerkinssQuilt.html
#include <iostream>
#include <cstring>
#include <algorithm>
#include <ctime>
using namespace std;
#ifndef DEBUG_MODE
#define DEBUG_MODE // 测试用,若在线提交,需要将该语句注释掉。
#endif
#define NMAX 20 // 拆分时,纸片最多需要的张数。
#define NPRIME 11 // 10 - 50 之间的质数个数。
#define SMAX 1024 // 最多保存的未成功拼接的拆分方案数。
#define PMAX 2500 // 网格中坐标最大个数。
#define NCELL 50 // 网格边长。
struct square // 表示拼接的纸片信息。
{
int x, y; // 纸片在网格中的坐标。
int size; // 纸片的边长。
};
square squares[NMAX]; // 记录当前的拼接方案。
square best[NMAX]; // 记录搜索得到的最好实际拼接方案。
struct point // 表示网格中的一个点。
{
int x; // 点的横坐标。
int y; // 点的纵坐标。
};
// 2 - 50 之间的奇数拼接时所需要的最少纸片数。
int tip[24] = { 6, 8, 9, 6, 11, 11, 6, 12, 13, 6, 13, 8, 6, 14, 15, 6, 8, 15, 6,
15, 16, 6, 16, 9
};
// 10 - 50 之间的质数的最佳拆分方案。数组第一个数表示质数,第二个数表示所需纸片数,其后的数字为
// 纸片大小,按纸片从大到小排列。
int trick[NPRIME][NMAX] = {
{11, 11, 6, 5, 5, 4, 2, 2, 2, 2, 1, 1, 1}, // 11
{13, 11, 7, 6, 6, 4, 3, 3, 2, 2, 2, 1, 1}, // 13
{17, 12, 9, 8, 8, 5, 4, 4, 3, 2, 2, 2, 1, 1}, // 17
{19, 13, 10, 9, 9, 5, 5, 5, 3, 2, 2, 2, 1, 1, 1}, // 19
{23, 13, 12, 11, 11, 7, 5, 5, 4, 3, 3, 2, 2, 1, 1}, // 23
{29, 14, 17, 12, 12, 9, 8, 8, 4, 4, 3, 2, 2, 2, 1, 1}, // 29
{31, 15, 16, 15, 15, 8, 8, 8, 4, 4, 4, 2, 2, 2, 1, 1, 1}, // 31
{37, 15, 19, 18, 18, 11, 8, 8, 6, 5, 5, 3, 3, 2, 1, 1, 1}, // 37
{41, 15, 23, 18, 18, 12, 11, 11, 7, 5, 4, 3, 3, 2, 2, 1, 1}, // 41
{43, 16, 22, 21, 21, 11, 11, 11, 6, 5, 5, 3, 3, 3, 2, 1, 1, 1}, // 43
{47, 16, 24, 23, 23, 12, 12, 12, 7, 5, 5, 4, 3, 3, 2, 2, 1, 1}, // 47
};
int n; // 要拼接的正方形边长。
int smallest; // 当前实际最佳拼接方案的纸片数。
int ncount[NCELL]; // 记录拼接方案中重复纸片的张数。
int cell[NCELL][NCELL]; // 尝试拼接时使用的网格。
int backup[NCELL][NCELL]; // 记录实际最佳方案网格状态。
int ncache[NMAX]; // 记录的未成功拼接的拆分方案个数。
int cache[NMAX][SMAX][NMAX]; // 记录未能成功拼接的拆分方案。
bool found; // 当前是否发现了非最优拆分方案的实际拼接方案。
bool finished; // 提前结束回溯的标志。
// 在网格 cell 中查找边长为 size 的空白区域的左上角坐标。
int find(int size, point points[PMAX])
{
// 初始时,找到的坐标个数为 0。
int npoints = 0;
for (int y = 0; y <= (n - size); y++)
for (int x = 0; x <= (n - size); x++)
// 找到了空白点。
if (cell[y][x] == 0)
{
// 查看此点是否存在边长为 size 的正方形空白区域。
bool empty = true;
for (int i = y; i < (y + size); i++)
{
for (int j = x; j < (x + size); j++)
if (cell[i][j] != 0)
{
empty = false;
break;
}
if (!empty)
break;
}
// 存在边长为 size 的空白区域,记录起点坐标。
if (empty)
{
points[npoints].x = x;
points[npoints].y = y;
npoints++;
}
}
return npoints;
}
// 输出拼接方案。
void print(square s[NMAX], int nsquares)
{
#ifdef DEBUG_MODE
cout << "A FILL SOLUTION FOR SQUARE WITH SIZE: " << n << endl;
for (int x = 0; x < n; x++)
{
for (int y = 0; y < n; y++)
cout << (char) ('A' + backup[x][y] - 1) << " ";
cout << endl;
}
#endif
cout << nsquares << endl;
for (int i = 0; i < nsquares; i++)
cout << s[i].x << " " << s[i].y << " " << s[i].size << endl;
}
// 尝试按照拆分方案 blocks 拼接边长为 n 的正方形。
void fill(int blocks[], int ncurrent, int goal, bool display_when_find)
{
// 所有纸片均已匹配,表明该拆分方案可行,输出。
if (ncurrent == goal)
{
memcpy(backup, cell, sizeof(cell));
// 是否显示结果。
if (display_when_find)
print(squares, ncurrent);
else
memcpy(best, squares, sizeof(squares));
finished = true;
}
else
{
int npoints; // 记录找到的坐标个数。
point points[PMAX]; // 记录起始坐标。
// 未找到则返回。
if ((npoints = find(blocks[ncurrent], points)) == 0)
return;
// 逐一尝试找到的位置。
for (int i = 0; i < npoints; i++)
{
int x = points[i].x;
int y = points[i].y;
int s = blocks[ncurrent];
// 启发式规则:第一张纸片总是放置在左上角。
if (ncurrent == 0 && (y != 0 || x != 0))
continue;
// 启发式规则:第二张纸片总是放置在右上角。
if (ncurrent == 1 && (y != 0 || x != blocks[0]))
continue;
// 启发式规则:第三张纸片总是放置在左下角。
if (ncurrent == 2 && (y != blocks[0] || x != 0))
continue;
// 启发式规则:第四张纸片总是靠近右侧边放置。
if (ncurrent == 3 && x != (n - blocks[ncurrent]))
continue;
// 启发式规则:第五张纸片总是靠近右侧边或下边放置。
if (ncurrent == 4 && (x != (n - blocks[ncurrent]) &&
y != (n - blocks[ncurrent])))
continue;
// 记录当前的拼接方法。注意坐标起点的不同,输出要求从起点 (1,1)
// 开始输出。
squares[ncurrent].x = (x + 1);
squares[ncurrent].y = (y + 1);
squares[ncurrent].size = s;
// 标记网格中的相应区域为填充状态。
for (int gy = y; gy < (y + s); gy++)
for (int gx = x; gx < (x + s); gx++)
cell[gy][gx] = s;
// 继续向前匹配下一张纸片。
fill(blocks, ncurrent + 1, goal, display_when_find);
// 是否结束回溯。
if (finished)
return;
// 未结束回溯,表明当前拼接方案不可行,撤销对网格的更改。
for (int gy = y; gy < (y + s); gy++)
for (int gx = x; gx < (x + s); gx++)
cell[gy][gx] = 0;
}
}
}
// 排序函数的顺序规则。
bool cmp(int x, int y)
{
return x > y;
}
// 使用最少纸片数作为剪枝阈值搜索拆分方案。
void cut_by_tip(int area, int blocks[NMAX], int nblocks, int goal)
{
// 当切分纸片数达到剪枝阈值,但仍有面积剩余,则结束回溯。
if (area > 0 && nblocks == goal)
return;
// 当切分完毕,切分的总纸片数不为剪枝阈值,则结束回溯。
if (area == 0 && nblocks != goal)
return;
// 切分完毕,且切分方案纸片张数为最少。
if (area == 0)
{
int temp[NMAX];
// 注意数组作为形式参数时,传递的是指针,故不能使用 sizeof(blocks) 来计算
// 数组 blocks 的大小。
memcpy(temp, blocks, NMAX * sizeof(int));
// 将纸片大小按从大到小排序。
sort(temp, temp + nblocks, cmp);
// 若在未成功拼接的方案中未找到当前切分方案,则尝试拼接。
bool exist = false;
for (int i = 0; i < ncache[nblocks - 1]; i++)
{
bool equal = true;
for (int j = 0; j < nblocks; j++)
if (cache[nblocks - 1][i][j] != temp[j])
{
equal = false;
break;
}
if (equal)
{
exist = true;
break;
}
}
// 不存在则尝试拼接。
if (!exist)
{
// 重置网格。
memset(cell, 0, sizeof(cell));
// 尝试拼接。
fill(temp, 0, nblocks, true);
// 成功则返回。
if (finished)
return;
// 拼接不成功,予以保存。
memcpy(cache[nblocks - 1][ncache[nblocks - 1]++],
temp, sizeof(temp));
}
}
else
{
// 找到能切分出的最大边长的纸片。
int up;
for (int u = n - 1; u >= 1; u--)
if (area >= (u * u))
{
up = u;
break;
}
// 启发式规则:优先考虑大小在 up / 2 + 1 和 up 之间的纸片。
for (int r = (up / 2 + 1); r <= up; r++)
{
// 启发式规则:第二张纸片的大小与第一张纸片的大小和为 n。
if (nblocks == 1 && (r + blocks[0]) != n)
continue;
// 启发式规则:第三张纸片的大小应该与第二张纸片的大小相同。
if (nblocks == 2 && r != blocks[1])
continue;
// 启发式规则:第四张纸片和第五张纸片的大小之和应该为第一张纸片的大小,
// 即拼接所得到的正方形某一边纸片数不能超过 3 张。
if (nblocks == 4 && (r + blocks[3]) != blocks[0])
continue;
// 记录当前切分。
blocks[nblocks] = r;
// 继续切分。
cut_by_tip(area - (r * r), blocks, nblocks + 1, goal);
// 根据 finished 标志决定是否提前退出。
if (finished)
return;
}
}
}
// 使用回溯法构建拆分方案。参数为尚未切分的面积数量。
void cut_by_hard_work(int area, int blocks[NMAX], int nblocks)
{
// 当切分纸片数达到当前可行的最小纸片数,但仍有面积剩余,不需继续尝试。
if (area >= 0 && nblocks > smallest)
return;
// 对于纸张数为 smallest 来说,已经找到了一个实际拼接方案,则对于同样的纸张数来说,其他
// 拆分方案不必再去尝试。
if (area == 0 && nblocks == smallest && found)
return;
// 启发式规则:至少有两张边长为 1 的纸片。
if (area == 0 && ncount[1] <= 1)
return;
// 切分完毕,且切分方案纸片张数较当前最优值 smallest 小。
if (area == 0)
{
int temp[NMAX];
// 注意数组作为形式参数时,传递的是指针,故不能使用 sizeof(blocks) 来计算
// 数组 blocks 的大小。
memcpy(temp, blocks, NMAX * sizeof(int));
// 将纸片大小按从大到小排序。
sort(temp, temp + nblocks, cmp);
// 不检测当前方案是否与之前生成的未能成功拼接的方案重复,会增加搜索时间。
// 但检测的话生成方案数很多,需要多量的内存。
// 重置网格。
memset(cell, 0, sizeof(cell));
// 尝试拼接。
finished = false;
fill(temp, 0, nblocks, false);
if (finished)
{
smallest = nblocks;
found = true;
}
}
else
{
// 找到能切分出的最大边长的纸片。
int c, r, up, down, step;
for (r = n - 2; r >= 1; r--)
if (area >= (r * r))
break;
c = r;
step = (nblocks == 0) ? 1 : (-1);
r = (nblocks == 0) ? 1 : r;
for (; c >= 1; c--, r += step)
{
// 启发式规则:第一张纸片的大小在 n / 2 + 1 和 n - 2 之间的纸片。
if (nblocks == 0 && r < (n / 2 + 1))
continue;
// 启发式规则:第二张纸片的大小与第一张纸片的大小和为 n。
if (nblocks == 1 && (r + blocks[0]) != n)
continue;
// 启发式规则:第三张纸片的大小应该与第二张纸片的大小相同。
if (nblocks == 2 && r != blocks[1])
continue;
// 启发式规则:第四张纸片和第五张纸片的大小之和应该为第一张纸片的大小,
// 即拼接所得到的正方形某一边纸片数不能超过 3 张。
if (nblocks == 4 && (r + blocks[3]) != blocks[0])
continue;
// 启发式规则:相同大小的纸片数不超过 4 张。
if ((ncount[r] + 1) > 4)
continue;
ncount[r]++;
// 记录当前切分。
blocks[nblocks] = r;
// 继续切分。
cut_by_hard_work(area - (r * r), blocks, nblocks + 1);
ncount[r]--;
}
}
}
// 使用已经生成好的最少纸片数拆分方案来得到拼接方案。
void solve_it_by_trick()
{
// 查找相应质数的的拆分方案。
int blocks[NMAX];
int nblocks;
for (int r = 0; r < NPRIME; r++)
if (trick[r][0] == n)
{
// 找到相应质数的数据,设置纸片总数及具体拆分方案。
nblocks = trick[r][1];
for (int c = 0; c < nblocks; c++)
blocks[c] = trick[r][c + 2];
break;
}
// 重置结束标志。
finished = false;
// 重置网格数组。
memset(cell, 0, sizeof(cell));
// 根据相应的最佳拆分方案拼接正方形。
fill(blocks, 0, nblocks, true);
}
// 使用最少纸片数拆分方案的纸片张数作为剪枝阈值,搜索可行的拼接方案。
void solve_it_by_tip()
{
int blocks[NMAX];
finished = false;
memset(ncache, 0, sizeof(ncache));
// 若使用网络已经提供的拼接边长为 n 的正方形至少需要的纸张数,则可大
// 大减少搜索时间,否则搜索时间很长。
int goal = tip[n / 2 - 1];
// 用回溯法将 n * n 拆分为不大于 smallest 个平方数之和。
cut_by_tip(n * n, blocks, 0, goal);
}
// 利用求最大公约数的辗转相除法得到较好的拼接剪枝阈值。
void gcd(int a, int b)
{
if (a < b)
{
int temp = a;
a = b;
b = temp;
}
smallest += (a / b) * 2;
if (a % b != 0)
gcd(a % b, b);
}
// 完全靠实时回溯生成最少纸片数的拼接方案。
void solve_it_by_hard_work()
{
int current[NMAX];
memset(ncache, 0, sizeof(ncache));
// 若使用网络已经提供的拼接边长为 n 的正方形至少需要的纸张数,则可大大减少搜索时间,否
// 则搜索时间很长。若不使用,则在计算时需要动态调整 smallest 的值。当 n 逐渐增大时,可
// 以选择较大的纸片来填充已减少剪枝阈值的值。
smallest = 1 + n / 2 + (n - 2) / 2 + 4;
// 当 n 值较大时,试图找到一个更好的剪枝阈值。可以这样寻找:先放一张边长为 s 的纸片在左
// 上角,然后再放一张边长为 (n - s) 的纸片在右下角,之后在剩余空间先填充边长为 (n -
// s) 的纸片,剩余的空间则尽可能填充大的正方形,余下的填充边长为 1 的正方形纸片,这样
// 获得的剪枝阈值较好。实际上可以利用求最大公约数的辗转相除法来得到。
int threshold = smallest;
for (int s = (n / 2 + 1); s < (n - 2); s++)
{
smallest = 2;
gcd(s, n - s);
if (threshold > smallest)
threshold = smallest;
}
smallest = threshold;
// 用回溯法将 n * n 拆分为不大于 smallest 个平方数之和。
cut_by_hard_work(n * n, current, 0);
// 输出最佳方案。
print(best, smallest);
}
// 输出在坐标 (x,y) 边长为 size 的纸片。
void building(int x, int y, int size)
{
cout << x << " " << y << " " << size << endl;
}
int main(int ac, char *av[])
{
#ifdef DEBUG_MODE
clock_t start = clock();
#endif
int cases; // 测试数据例数。
cin >> cases;
while (cases--)
{
cin >> n;
// 若 n 为偶数,则直接输出拼接方案。
if (n % 2 == 0)
{
int size = n / 2;
cout << "4" << endl;
building(1, 1, size);
building(1, 1 + size, size);
building(1 + size, 1, size);
building(1 + size, 1 + size, size);
}
// 若 n 为形如 6 * m + 3 的数,则拼接方案与 n = 3 时相同,直接输出拼接方案。
else if (n % 6 == 3)
{
int size = n / 3;
cout << "6" << endl;
building(1, 1, size * 2);
building(1 + size * 2, 1, size);
building(1 + size * 2, 1 + size, size);
building(1 + size * 2, 1 + size * 2, size);
building(1, 1 + size * 2, size);
building(1 + size, 1 + size * 2, size);
}
// 对于 m 和 n,m 为质数且是能整除 n 的最小质数,则有 g(m) = g(n),且
// 拼接方案类似。若 n 为奇数,且 5 是能整除 n 的最小质数,则 g(5) = g(n),
// 包括 5 和 25。
else if (n % 5 == 0)
{
int size = n / 5;
cout << "8" << endl;
building(1, 1, size * 3);
building(1 + size * 3, 1, size * 2);
building(1 + size * 3, 1 + size * 2, size * 2);
building(1, 1 + size * 3, size * 2);
building(1 + size * 2, 1 + size * 3, size);
building(1 + size * 2, 1 + size * 4, size);
building(1 + size * 3, 1 + size * 4, size);
building(1 + size * 4, 1 + size * 4, size);
}
// 若 n 为奇数,且 7 是能整除 n 的最小质数,则 g(7) = g(n),包括 7 和 49。
else if (n % 7 == 0)
{
int size = n / 7;
cout << "9" << endl;
building(1, 1, size * 4);
building(1 + size * 4, 1, size * 3);
building(1, 1 + size * 4, size * 3);
building(1 + size * 3, 1 + size * 5, size * 2);
building(1 + size * 5, 1 + size * 5, size * 2);
building(1 + size * 5, 1 + size * 3, size * 2);
building(1 + size * 4, 1 + size * 3, size);
building(1 + size * 4, 1 + size * 4, size);
building(1 + size * 3, 1 + size * 4, size);
}
// 对于其他情况,通过回溯找到满足题意的方案。
else
{
// 使用已经生成好的拆分方案尝试拼接。使用此方法 UVa RT 为 0.032s。
solve_it_by_trick();
// 直接使用最少纸片数作为剪枝阈值,使用回溯方法获得拆分方案,使用此
// 方法得到 10 - 50 之间的所有质数的拆分方案运行时间为 27s。
// solve_it_by_tip();
// 完全靠实时回溯获得拆分方案,然后尝试拼接,剪枝阈值使用非最优方案的
// 纸片数。使用此方法在我的笔记本上 (Intel Core2 T5200 1.60GHz,
// 2.0GiB 内存) 运行了半个多小时才得到 10 - 50 之间质数的拼接方案。
// solve_it_by_hard_work();
}
}
#ifdef DEBUG_MODE
cout << "TIME ELAPSED: " << (clock() -
start) / CLOCKS_PER_SEC << " s." << endl;
#endif
return 0;
}
UVa Problem 10270 Bigger Square Please... (拼接正方形)
最新推荐文章于 2021-01-12 18:05:42 发布