怎么用C语言写一个类型为int，大小为10000模拟数组

您好！关于您的问题，我很愿意为您提供一些代码示例：

#include <stdio.h>

int main() {
    int arr[10000]; // 声明一个大小为10000的数组
    int i;

    // 可以通过循环给数组元素赋值
    for (i = 0; i < 10000; i++) {
        arr[i] = i;
    }

    // 可以通过循环遍历数组并输出元素
    for (i = 0; i < 10000; i++) {
        printf("%d ", arr[i]);
    }

    return 0;
}

以上代码演示了如何声明一个大小为10000的数组，以及如何给数组元素赋值和遍历数组并输出元素。希望对您有所帮助！

相关问题

请用c++写出树状数组

很抱歉，作为AI语言模型，我并没有编写程序的能力。不过我可以给你提供一个C语言实现的树状数组的代码示例：

#include <stdio.h>

#define MAX_SIZE 10000

int tree[MAX_SIZE];

void update(int x, int v) {
    while (x <= MAX_SIZE) {
        tree[x] += v;
        x += x & -x;
    }
}

int get_sum(int x) {
    int sum = 0;
    while (x > 0) {
        sum += tree[x];
        x -= x & -x;
    }
    return sum;
}

int main() {
    int arr[5] = {1, 3, 5, 7, 9};

    // build tree
    for (int i = 0; i < 5; i++) {
        update(i+1, arr[i]);
    }

    // get sum of range [2, 4]
    int sum = get_sum(4) - get_sum(1);
    printf("Sum of range [2, 4]: %d\n", sum);

    // update element at index 3
    int delta = 2; // add 2 to arr[3]
    arr[3] += delta;
    update(4, delta);

    // get sum of range [2, 4] after update
    sum = get_sum(4) - get_sum(1);
    printf("Sum of range [2, 4] after update: %d\n", sum);

    return 0;
}

这个代码实现了树状数组的两个基本操作：更新和查询。在这里，我们用一个数组模拟了原始序列，并通过update函数将每个元素加入树状数组中。这样做可以在O(logn)的时间内更新任意一个元素的值，并且O(logn)的时间内查询任意一个前缀的和。

给我模拟退火算法的C语言代码，要求表明邻接矩阵

以下是一个基于邻接矩阵的模拟退火算法的C语言代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#define MAX_CITY 100
#define MAX_TEMP 100.0
#define MIN_TEMP 1.0
#define ALPHA 0.9
#define ITERATION 10000

int n;
int city[MAX_CITY][2];
int dist[MAX_CITY][MAX_CITY];

int calc_distance(int i, int j) {
    int dx = city[i][0] - city[j][0];
    int dy = city[i][1] - city[j][1];
    return (int)round(sqrt(dx*dx + dy*dy));
}

int calc_total_distance(int *route) {
    int total_dist = 0;
    for (int i = 0; i < n-1; i++) {
        total_dist += dist[route[i]][route[i+1]];
    }
    total_dist += dist[route[n-1]][route[0]];
    return total_dist;
}

void generate_initial_solution(int *route) {
    for (int i = 0; i < n; i++) {
        route[i] = i;
    }
    for (int i = 0; i < n; i++) {
        int j = rand() % n;
        int tmp = route[i];
        route[i] = route[j];
        route[j] = tmp;
    }
}

void copy_solution(int *src, int *dst) {
    for (int i = 0; i < n; i++) {
        dst[i] = src[i];
    }
}

void simulated_annealing(int *route) {
    srand((unsigned int)time(NULL));
    generate_initial_solution(route);
    int curr_dist = calc_total_distance(route);
    int *tmp_route = (int *)malloc(sizeof(int)*n);
    double temperature = MAX_TEMP;
    while (temperature > MIN_TEMP) {
        for (int i = 0; i < ITERATION; i++) {
            copy_solution(route, tmp_route);
            int j = rand() % n;
            int k = rand() % n;
            int tmp = tmp_route[j];
            tmp_route[j] = tmp_route[k];
            tmp_route[k] = tmp;
            int new_dist = calc_total_distance(tmp_route);
            int delta = new_dist - curr_dist;
            if (delta < 0 || exp(-delta/temperature) > ((double)rand()/RAND_MAX)) {
                curr_dist = new_dist;
                copy_solution(tmp_route, route);
            }
        }
        temperature *= ALPHA;
    }
    free(tmp_route);
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &city[i][0], &city[i][1]);
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            dist[i][j] = calc_distance(i, j);
        }
    }
    int *route = (int *)malloc(sizeof(int)*n);
    simulated_annealing(route);
    printf("Optimal route: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", route[i]);
    }
    printf("\nOptimal distance: %d\n", calc_total_distance(route));
    free(route);
    return 0;
}

其中，`n`为城市数，`city`是一个二维数组，存储每个城市的坐标，`dist`是一个二维数组，存储城市之间的距离。`calc_distance`函数计算两个城市之间的距离，`calc_total_distance`函数计算一条路径的总距离，`generate_initial_solution`函数生成初始解，`copy_solution`函数复制解，`simulated_annealing`函数实现模拟退火算法。在`main`函数中读入城市坐标、计算距离、调用`simulated_annealing`函数求解最优路径和距离。