OJ测试数据生成器
测试数据生成器
-
- 先序二叉树生成器
- 哈夫曼树生成器
- 哈夫曼树解码生成器
- 多叉树生成器
- 多叉树的孩子链表法表示生成器
- 多叉树的双亲表示法生成器
- 图的邻接表表示生成器
- 矩阵表示法的图
- 图的最短路径（无框架）
- 拓扑排序
可以使用本文中提到的数据生成器生成OJ中的测试数据，对自己代码进行测试对拍，或对OJ后台数据进行补充。
先序二叉树生成器
基于Python的cyaron库实现。可以生成若干个二叉树的先序序列。
from cyaron import *
global tree
global ans
def outPut(i):
if i > len(tree) or tree[i] == -1:
ans.append(0)
return
ans.append(tree[i])
outPut(i * 2 + 1)
outPut(i * 2 + 2)
if __name__ == '__main__':
_n = [20, 21, 22, 23, 24, 25, 26]
_m = ['A']
for ii in range(1, 5):
print("working on %d" % ii)
io = IO(file_prefix="test", data_id=ii)
n = _n[ii % len(_n)]
nn = randint(20, 50)
io.input_writeln(nn)
for j in range(nn):
binary_tree = Graph.binary_tree(n)
ans = []
tree = [-1] * pow(2, n)
tree[0] = 1
for edge in binary_tree.iterate_edges():
i = 0
for i in range(0, len(tree)):
if tree[i] == edge.start:
break
if tree[i * 2 + 1] == -1:
tree[i * 2 + 1] = edge.end
else:
tree[i * 2 + 2] = edge.end
outPut(0)
res = ""
for i in ans:
if i == 0:
res += "0"
else:
res += chr(ord(_m[j % len(_m)]) + i - 1)
io.input_writeln(res)
io.output_gen("ans.exe")
哈夫曼树生成器
基于C++实现，便于生成多组测试数据，本生成器可完美适配赫夫曼树的构建与编码，经过修改后可以适配多种题目。为了避免导致因相同权值造成的多解问题导致的可能答案错误，添加了保证哈夫曼树唯一性的检测函数。
#include 哈夫曼树解码生成器
基于C++实现，便于生成多组测试数据，本生成器可完美适配赫夫曼树解码，经过修改后可以适配多种题目。为了避免导致因相同权值造成的多解问题导致的可能答案错误，添加了保证哈夫曼树唯一性的检测函数，并使用随机数函数生成有解或无解的测试序列。
#include 多叉树生成器
基于C++实现，便于生成多组测试数据，本生成器可完美适配DS森林叶子编码，经过修改后可以适配多种OJ题，便于生成测试数据进行对拍。
#include 多叉树的孩子链表法表示生成器
基于C++实现，生成使用孩子链表法表示的多叉树，可以直接适配树的后根遍历（孩子链表法）
#include 多叉树的双亲表示法生成器
基于C++实现，生成使用双亲表示法表示的多叉树，可以直接适配树的先序遍历（双亲表示法）
#include 图的邻接表表示生成器
基于Python实现，用于生成图的邻接表表示法的测试数据。
from cyaron import *
if __name__ == '__main__':
for ii in range(1, 6):
print("working on %d" % ii)
io = IO(file_prefix="", data_id=ii)
T = randint(20, 30)
io.input_writeln(T)
for i in range(T):
n = randint(20, 25)
m = randint(3 * n, 6 * n)
io.input_writeln(n, m)
graph = Graph.graph(n, m, self_loop=False, repeated_edges=False)
seq = [chr(ord('A') + i) for i in range(0, n)]
ans = ""
for i in seq:
ans += str(i) + " "
io.input_writeln(ans.strip())
edges = []
for edge in graph.iterate_edges():
edges.append(chr(ord('A') - 1 + edge.start) + " " + chr(ord('A') - 1 + edge.end))
edges.sort()
for i in edges:
io.input_writeln(i)
矩阵表示法的图
from cyaron import *
if __name__ == '__main__':
for ii in range(1, 6):
print("working on %d" % ii)
io = IO(file_prefix="", data_id=ii)
T = randint(20, 30)
io.input_writeln(T)
for i in range(T):
n = randint(20, 25)
m = randint(3 * n, 6 * n)
io.input_writeln(n)
graph = Graph.graph(n, m, self_loop=False, repeated_edges=False)
g = [[0 for ii in range(n)] for jj in range(n)]
for edge in graph.iterate_edges():
g[edge.start - 1][edge.end - 1] = 1
g[edge.end - 1][edge.start - 1] = 1
ans = str(g).replace('[', '').replace(']', '\n').replace(',', '').replace('\n ', '\n').strip()
io.input_writeln(ans)
图的最短路径（无框架）
from itertools import product
from random import shuffle
from cyaron import *
if __name__ == '__main__':
for ii in range(1, 6):
print("working on %d" % ii)
io = IO(file_prefix="", data_id=ii)
T = randint(10, 20)
io.input_writeln(T)
letters = "abcdefghijklmnopqrstuvwxyz"
letters += letters.upper()
letters_combinations = ["".join(x) for x in product(letters, repeat=2)]
for i in range(T):
shuffle(letters_combinations)
n = randint(20, 25)
m = randint(2 * n, 10 * n)
tmp = randint(1, 100)
al = [n]
for j in range(n):
al.append(letters_combinations[j])
io.input_writeln(al)
graph = Graph.graph(n, m, directed=True, self_loop=False, repeated_edges=False, weight_limit=(10, 100))
g = [[0 for ii in range(n)] for jj in range(n)]
for edge in graph.iterate_edges():
g[edge.start - 1][edge.end - 1] = edge.weight
matrix = str(g).replace('[', '').replace(']', '\n').replace(',', '').replace('\n ', '\n').strip()
io.input_writeln(matrix)
io.input_writeln(letters_combinations[randint(0, n)])
io.output_gen("ans.exe")
拓扑排序
from itertools import product
from random import shuffle
from cyaron import *
from random import shuffle as sl
from random import randint as rd
def random_graph(node, edge):
n = node
node = range(0, n)
node = list(node)
sl(node) # 生成拓扑排序
m = edge
result = [] # 存储生成的边，边用tuple的形式存储
appeared_node = []
not_appeared_node = node
# 生成前n - 1条边
while len(result) != n - 1:
# 生成第一条边
if len(result) == 0:
p1 = rd(0, n - 2)
p2 = rd(p1 + 1, n - 1)
x = node[p1]
y = node[p2]
appeared_node.append(x)
appeared_node.append(y)
not_appeared_node = list(set(node).difference(set(appeared_node)))
result.append((x, y))
# 生成后面的边
else:
p1 = rd(0, len(appeared_node) - 1)
x = appeared_node[p1] # 第一个点从已经出现的点中选择
p2 = rd(0, len(not_appeared_node) - 1)
y = not_appeared_node[p2]
appeared_node.append(y) # 第二个点从没有出现的点中选择
not_appeared_node = list(set(node).difference(set(appeared_node)))
# 必须保证第一个点的排序在第二个点之前
if node.index(y) < node.index(x):
result.append((y, x))
else:
result.append((x, y))
# 生成后m - n + 1条边
while len(result) != m:
p1 = rd(0, n - 2)
p2 = rd(p1 + 1, n - 1)
x = node[p1]
y = node[p2]
# 如果该条边已经生成过，则重新生成
if (x, y) in result:
continue
else:
result.append((x, y))
mat = [[0] * n for i in range(n)]
for i in range(len(result)):
mat[result[i][0]][result[i][1]] = 1
return node, list(result), mat
if __name__ == '__main__':
for ii in range(1, 6):
print("working on %d" % ii)
io = IO(file_prefix="", data_id=ii)
T = randint(10, 20)
io.input_writeln(T)
for i in range(T):
n = randint(20, 25)
m = randint(n, int(2 * n))
io.input_writeln(n)
tp, edges, graph = random_graph(n, m)
matrix = str(graph).replace('[', '').replace(']', '\n').replace(',', '').replace('\n ', '\n').strip()
io.input_writeln(matrix)
io.output_gen("ans.exe")