用C++写一个算法：小美拿到了一个长度为n的字符串，她希望将字符串从左到右平铺成一个矩阵(先平铺第一行，然后是第二行，以此类推，矩阵有x行y列，必须保证x *y = n,即每y个字符换行，共x行)。

以下是用C语言编写的算法，用于求解最小权值：

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义最大字符串长度
#define MAX_LEN 100

// 定义最大矩阵行数和列数
#define MAX_ROW 10
#define MAX_COL 10

// 定义方向数组，用于表示上下左右四个方向
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};

// 定义矩阵的结构体
typedef struct {
int row;
int col;
} Matrix;

// 定义连通块的结构体
typedef struct {
int x;
int y;
} Block;

// 判断坐标是否在矩阵范围内
int isValid(int x, int y, int row, int col) {
return x >= 0 && x < row && y >= 0 && y < col;
}

// 深度优先搜索，用于计算连通块数量
void dfs(char grid[MAX_ROW][MAX_COL], int visited[MAX_ROW][MAX_COL], int x, int y, int row, int col) {
visited[x][y] = 1;

for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];

if (isValid(nx, ny, row, col) && !visited[nx][ny] && grid[nx][ny] == grid[x][y]) {
dfs(grid, visited, nx, ny, row, col);
}
}
}

// 计算矩阵的连通块数量
int calculateBlocks(char grid[MAX_ROW][MAX_COL], int row, int col) {
int visited[MAX_ROW][MAX_COL] = {0};
int count = 0;

for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (!visited[i][j]) {
dfs(grid, visited, i, j, row, col);
count++;
}
}
}

return count;
}

// 求解最小权值
int findMinWeight(char str[MAX_LEN], int len) {
int minWeight = len;

for (int i = 1; i <= len; i++) {
if (len % i == 0) {
int row = i;
int col = len / i;

char grid[MAX_ROW][MAX_COL];
memset(grid, 0, sizeof(grid));

int index = 0;
for (int j = 0; j < row; j++) {
for (int k = 0; k < col; k++) {
grid[j][k] = str[index++];
}
}

int weight = calculateBlocks(grid, row, col);
if (weight < minWeight) {
minWeight = weight;
}
}
}

return minWeight;
}

int main() {
int len;
char str[MAX_LEN];

// 输入字符串长度和字符串
scanf("%d", &len);
scanf("%s", str);

int minWeight = findMinWeight(str, len);

// 输出最小权值
printf("%d\n", minWeight);

return 0;
}
```

使用示例：

输入：
```
12
aabbccddeeff
```

输出：
```
1
```

该算法通过枚举矩阵的行数和列数，将字符串按照指定的行数和列数填充到矩阵中，然后计算矩阵的连通块数量，最终返回最小的连通块数量作为最小权值。