int main (void)
{
int i;
int min;
int size;
int grid[MAX_GRID * MAX_GRID];
int nLogs;
/* Read grid size and number of logs. */
scanf ("%d %d", &size, &nLogs);
/* Read log pile locations. */
for (i = 0; i < size * size; i++) {
scanf ("%d", &grid[i]);
}
/* Place logs. */
while (nLogs > 0) {
grid[findMinIndex (grid, size)]++;
nLogs--;
}
/* Print grid. */
for (i = 0; i < size * size; i++) {
printf ("%d ", grid[i]);
if ((i+1) % size == 0) {
printf ("\n");
}
}
return 0;
}
Index bTree::findMinIndex(bTreeNode& node){
Index res;
if(node.type==LEAF)
res=node.indexList.front();
else
{
bTreeNode temp = assignNode(node.ptrList.front());
res = findMinIndex(temp);
freeNode(temp);
}
return res;
}
int main (void)
{
int i;
int index;
int diff;
int len; /* length of grid */
int size; /* size of grid = length * length */
int nLogs; /* number of logs */
int *grid; /* pile locations array */
/* Read grid size and number of logs. */
scanf ("%d %d", &len, &nLogs);
size = len * len;
/* Allocate grid array. */
grid = (int *) malloc (sizeof (int) * size);
/* Read log pile locations. */
for (i = 0; i < size; i++) {
scanf ("%d", &grid[i]);
}
/* Place logs. */
while (nLogs > 0) {
index = findMinIndex (grid, size, &diff);
/* If the minimum difference is zero, add 1 rod, not 0. */
if (diff == 0) {
diff = 1;
}
grid[index] += diff;
nLogs -= diff;
}
/* Print grid. */
for (i = 0; i < size; i++) {
printf ("%d ", grid[i]);
if ((i+1) % len == 0) {
printf ("\n");
}
}
/* Clean up. */
free (grid);
return 0;
}
//排序函数
void sort(int p[],const int len)
{
int i;
int temp;
int min;
//接收用户输入
for( i = 0; i < len; i++)
{
printf("请输入第%d个元素：",i+1);
scanf("%d",&p[i]);
}
//输出原始状态的数组
printf("数组的初始状态是：");
for(i = 0; i < len; i++)
printf("%d ",p[i]);
printf("\n");
//按要求排序
for(i = len; i >= 2; i--)
{
min = findMinIndex(p,i); //调用找最小值下标的函数
temp = p[i-1];
p[i-1] = p[min];
p[min] = temp;
}
//输出排序后的结果
printf("排序后数组的状态是：");
for(i = 0; i < len; i++)
printf("%d ",p[i]);
printf("\n");
system("pause");
exit(0);
}
void bTree::deleteNode(unsigned int parent, unsigned int path){
findPath.pop_back();
unsigned int i;
bTreeNode cur = assignNode(parent);
cur.dirty = true;
Index backupInd;
backupInd = cur.indexList.front();
if (path > 0)
cur.indexList.erase(cur.indexList.begin()+path-1);
else
cur.indexList.erase(cur.indexList.begin()+path);
cur.ptrList.erase(cur.ptrList.begin()+path);
cur.valNum--;
if(cur.type != ROOT && cur.valNum+1<(cur.maxNum+2)/2)
{
bTreeNode left,right;
unsigned int path = findPath.back();
bTreeNode temp = findBro(cur);
if(temp.type == INIT)
{
freeNode(cur);
return;
}
if(temp.indexList.front()<backupInd)
{
left = temp;
right = cur;
}
else
{
left = cur;
right = temp;
path++;
}
left.dirty = true;
right.dirty = true;
if(left.valNum + right.valNum + 2 <= left.maxNum + 1)
{
left.indexList.push_back(findMinIndex(right));
unsigned int i;
for (i = 0; i < right.valNum; ++i)
{
left.indexList.push_back(right.indexList[i]);
left.ptrList.push_back(right.ptrList[i]);
bTreeNode temp = assignNode(right.ptrList[i]);
temp.dirty = true;
temp.parentPtr = left.blockNo;
freeNode(temp);
}
left.ptrList.push_back(right.ptrList.back());
bTreeNode temp = assignNode(right.ptrList.back());
temp.dirty = true;
temp.parentPtr = left.blockNo;
freeNode(temp);
left.valNum+=right.valNum+1;
freeNode(left);
cleanNode(right);
deleteNode(right.parentPtr,path);
}
else
{
unsigned int half = (left.valNum + right.valNum + 2) / 2;
unsigned int i;
right.indexList.insert(right.indexList.begin(),findMinIndex(right));
for (i = left.valNum+1; i < half; ++i)
{
left.indexList.push_back(right.indexList.front());
left.ptrList.push_back(right.ptrList.front());
left.valNum++;
right.ptrList.erase(right.ptrList.begin());
right.indexList.erase(right.indexList.begin());
right.valNum--;
bTreeNode temp = assignNode(left.ptrList.back());
temp.dirty = true;
temp.parentPtr = left.blockNo;
freeNode(temp);
}
for (i = left.valNum; i >= half; --i)
{
right.indexList.insert(right.indexList.begin(),left.indexList.back());
right.ptrList.insert(right.ptrList.begin(),left.ptrList.back());
right.valNum++;
left.ptrList.erase(left.ptrList.end());
left.indexList.erase(left.indexList.end());
left.valNum--;
bTreeNode temp = assignNode(right.ptrList.front());
temp.dirty = true;
temp.parentPtr = right.blockNo;
freeNode(temp);
}
right.indexList.erase(right.indexList.begin());
bTreeNode temp = assignNode(right.parentPtr);
temp.dirty = true;
temp.indexList[path-1] = findMinIndex(right);
freeNode(temp);
freeNode(left);
freeNode(right);
}
}
else if(cur.type==ROOT&&cur.valNum==0)
{
bTreeNode temp = assignNode(cur.ptrList.front());
if(temp.type == LEAF)
{
freeNode(temp);
freeNode(cur);
return;
}
temp.dirty = true;
temp.type = ROOT;
temp.parentPtr = 0;
cleanNode(cur);
freeNode(temp);
root = temp.blockNo;
}
else
freeNode(cur);
return;
}
