答案daanC语言 - 技术栈

问题1：

#include <stdlib.h>

typedef struct {

int flag;

int row;

int col;

} UserInfo;

// 群信息：标识码 + 创建者中心位置 + 成员数

typedef struct {

int flag;

int centerRow;

int centerCol;

int count;

} Group;

static int *Resolve(const UserInfo *members, size_t membersSize, size_t *returnSize)

{

Group groups $100$ ; // 人数上限100，群数最多100

int groupCnt = 0;

for (size_t i = 0; i < membersSize; i++) {

int f = members $i$ .flag;

int r = members $i$ .row;

int c = members $i$ .col;

int found = -1;

// 从前往后找第一个同标识码且九宫格覆盖该点的群（即最早建立的）

for (int j = 0; j < groupCnt; j++) {

if (groups $j$ .flag == f &&

abs(r - groups $j$ .centerRow) <= 1 &&

abs(c - groups $j$ .centerCol) <= 1) {

found = j;

break;

}

if (found == -1) {

// 没有被覆盖，以本人位置为中心新建群

groups $groupCnt$ .flag = f;

groups $groupCnt$ .centerRow = r;

groups $groupCnt$ .centerCol = c;

groups $groupCnt$ .count = 1;

groupCnt++;

} else {

// 加入已存在的群

groups $found$ .count++;

}

// 收集所有群的成员数量，按题目要求需 malloc 返回

int *result = (int *)malloc(sizeof(int) * (groupCnt > 0 ? groupCnt : 1));

for (int i = 0; i < groupCnt; i++) {

result $i$ = groups $i$ .count;

}

// 从大到小排序

for (int i = 0; i < groupCnt - 1; i++) {

for (int j = i + 1; j < groupCnt; j++) {

if (result $i$ < result $j$ ) {

int tmp = result $i$ ;

result $i$ = result $j$ ;

result $j$ = tmp;

}

*returnSize = groupCnt;

return result;

}

问题2：

#include <stdlib.h>

#include <string.h>

typedef struct {

unsigned char *mem; // 内存数据

int size; // 总字节数

struct Block {

int start; // 块起始地址

int size; // 块大小

int used; // 1:已分配, 0:空闲

int appId; // 所属应用

} blocks $256$ ;

int blockCnt; // 当前块数量

} MemorySys;

// 16进制字符转数值

static int hexCharToInt(char c)

{

if (c >= '0' && c <= '9') return c - '0';

return c - 'A' + 10;

}

// 数值转16进制字符

static char intToHexChar(int v)

{

if (v < 10) return '0' + v;

return 'A' + v - 10;

}

// 初始化内存系统

static MemorySys *MemorySysCreate(const char *data)

{

MemorySys *sys = (MemorySys *)malloc(sizeof(MemorySys));

int len = (int)strlen(data);

sys->size = len / 2;

sys->mem = (unsigned char *)malloc(sys->size);

for (int i = 0; i < sys->size; i++) {

sys->mem $i$ = (hexCharToInt(data $i \* 2$ ) << 4) | hexCharToInt(data $i \* 2 + 1$ );

}

// 初始整块空闲

sys->blockCnt = 1;

sys->blocks $0$ .start = 0;

sys->blocks $0$ .size = sys->size;

sys->blocks $0$ .used = 0;

sys->blocks $0$ .appId = -1;

return sys;

}

// 申请内存：从低地址开始找第一个足够大的连续空闲块

static int MemorySysApplyMem(MemorySys *sys, int appId, int memSize)

{

for (int i = 0; i < sys->blockCnt; i++) {

if (!sys->blocks $i$ .used && sys->blocks $i$ .size >= memSize) {

int start = sys->blocks $i$ .start;

int oldSize = sys->blocks $i$ .size;

if (oldSize > memSize) {

// 分裂：前部分分配，后部分空闲

for (int j = sys->blockCnt; j > i + 1; j--) {

sys->blocks $j$ = sys->blocks $j - 1$ ;

}

sys->blocks $i$ .size = memSize;

sys->blocks $i$ .used = 1;

sys->blocks $i$ .appId = appId;

sys->blocks $i + 1$ .start = start + memSize;

sys->blocks $i + 1$ .size = oldSize - memSize;

sys->blocks $i + 1$ .used = 0;

sys->blocks $i + 1$ .appId = -1;

sys->blockCnt++;

} else {

sys->blocks $i$ .used = 1;

sys->blocks $i$ .appId = appId;

}

return start;

}

return -1;

}

// 释放指定应用的所有内存块，并合并相邻空闲块

static void MemorySysFreeMem(MemorySys *sys, int appId)

{

for (int i = 0; i < sys->blockCnt; i++) {

if (sys->blocks $i$ .used && sys->blocks $i$ .appId == appId) {

sys->blocks $i$ .used = 0;

sys->blocks $i$ .appId = -1;

}

// 合并相邻空闲块

int i = 0;

while (i < sys->blockCnt - 1) {

if (!sys->blocks $i$ .used && !sys->blocks $i + 1$ .used) {

sys->blocks $i$ .size += sys->blocks $i + 1$ .size;

for (int j = i + 1; j < sys->blockCnt - 1; j++) {

sys->blocks $j$ = sys->blocks $j + 1$ ;

}

sys->blockCnt--;

} else {

i++;

}

// 写内存：校验通过后写入4字节

static int MemorySysWriteData(MemorySys *sys, int verifyWord, int addr, const char *content)

{

int idx = -1;

for (int i = 0; i < sys->blockCnt; i++) {

if (sys->blocks $i$ .used &&

addr >= sys->blocks $i$ .start &&

addr < sys->blocks $i$ .start + sys->blocks $i$ .size) {

idx = i;

break;

}

if (idx == -1) return -1;

int start = sys->blocks $idx$ .start;

int size = sys->blocks $idx$ .size;

int appId = sys->blocks $idx$ .appId;

int word = (33 * (33 * start + size + appId)) % 251;

if (word != verifyWord) return 0;

for (int i = 0; i < 4; i++) {

unsigned char byte = (hexCharToInt(content $i \* 2$ ) << 4) |

hexCharToInt(content $i \* 2 + 1$ );

sys->mem $addr + i$ = byte;

}

return 1;

}

// 查询完整内存数据，返回16进制字符串

static char *MemorySysQuery(MemorySys *sys)

{

char *res = (char *)malloc(sys->size * 2 + 1);

for (int i = 0; i < sys->size; i++) {

res $i \* 2$ = intToHexChar(sys->mem $i$ >> 4);

res $i \* 2 + 1$ = intToHexChar(sys->mem $i$ & 0xF);

}

res $sys-\>size \* 2$ = '\0';

return res;

}

// 释放内存系统

static void MemorySysFree(MemorySys *sys)

{

if (sys != NULL) {

free(sys->mem);

free(sys);

}

问题3：

#include <string.h>

typedef struct {

int nodeId;

int childId;

} Node;

#define MAX_NODES 1001

static int parentArr $MAX_NODES$ ;

static int children $MAX_NODES$ $MAX_NODES$ ;

static int childCnt $MAX_NODES$ ;

static int state $MAX_NODES$ ;

static int nodeUsed $MAX_NODES$ ;

// 构建树，初始所有节点为未选中(0)

static void buildTree(const Node *dirTree, size_t dirTreeSize)

{

memset(parentArr, -1, sizeof(parentArr));

memset(childCnt, 0, sizeof(childCnt));

memset(state, 0, sizeof(state));

memset(nodeUsed, 0, sizeof(nodeUsed));

for (size_t i = 0; i < dirTreeSize; i++) {

int p = dirTree $i$ .nodeId;

int c = dirTree $i$ .childId;

nodeUsed $p$ = 1;

nodeUsed $c$ = 1;

parentArr $c$ = p;

children $p$ $childCnt\[p$ ++] = c;

}

// 递归设置某节点及其所有子节点的状态

static void setSubtree(int node, int target)

{

state $node$ = target;

for (int i = 0; i < childCnt $node$ ; i++) {

setSubtree(children $node$ $i$ , target);

}

// 根据子节点状态向上更新父节点

static void updateParent(int node)

{

int p = parentArr $node$ ;

if (p == -1) return;

int allSelected = 1;

int allUnselected = 1;

for (int i = 0; i < childCnt $p$ ; i++) {

int s = state $children\[p$ $i$ ];

if (s != 2) allSelected = 0;

if (s != 0) allUnselected = 0;

}

int newState = 1; // 半选

if (allSelected) newState = 2;

else if (allUnselected) newState = 0;

if (state $p$ != newState) {

state $p$ = newState;

updateParent(p);

}

static int SelectNodes(const Node *dirTree, size_t dirTreeSize, const int *operations, size_t operationsSize)

{

buildTree(dirTree, dirTreeSize);

for (size_t i = 0; i < operationsSize; i++) {

int op = operations $i$ ;

// 选中(2)则取消，否则选中

int target = (state $op$ == 2) ? 0 : 2;

setSubtree(op, target);

updateParent(op);

}

int unselected = 0;

for (int i = 0; i < MAX_NODES; i++) {

if (nodeUsed $i$ && state $i$ == 0) {

unselected++;

}

return unselected;

}