▶ 《并行程序设计导论》第六章中讨论了 n 体问题，分别使用了 MPI，Pthreads，OpenMP 来进行实现，这里是 OpenMP 的代码，分为基本算法和简化算法（引力计算量为基本算法的一半，但是消息传递较为复杂）

● 基本算法

 // omp_nbody_basic.c，OpenMP 基本算法

 #include <stdio.h>

 #include <stdlib.h>

 #include <string.h>

 #include <math.h>

 #include <omp.h>

 #define OUTPUT

 #define DEBUG

 #define DIM     2

 #define X       0

 #define Y       1

 typedef double vect_t[DIM];

 const double G = 6.673e-11;

 struct particle_s   // 使用一个结构来同时保存一个颗粒的质量，位置，速度

 {

     double m;

     vect_t s;

     vect_t v;

 };

 void Usage(char* prog_name)

 {

     fprintf(stderr, "usage: %s <nThreads> <nParticles> <nTimestep> <sizeTimestep> <outputFrequency> <g|i>\n", prog_name);

     fprintf(stderr, "    'g': inite condition by random\n    'i': inite condition from stdin\n");

     exit();

 }

 void Get_args(int argc, char* argv[], int* thread_count_p, int* n_p, int* n_steps_p, double* delta_t_p, int* output_freq_p, char* g_i_p)

 {

     if (argc != )

         Usage(argv[]);

     *thread_count_p = strtol(argv[], NULL, );

     *n_p = strtol(argv[], NULL, );

     *n_steps_p = strtol(argv[], NULL, );

     *delta_t_p = strtod(argv[], NULL);

     *output_freq_p = strtol(argv[], NULL, );

     *g_i_p = argv[][];

     if (*thread_count_p <  || *n_p <=  || *n_p % *thread_count_p || *n_steps_p <  || *delta_t_p <=  || *g_i_p != 'g' && *g_i_p != 'i')

     {

         Usage(argv[]);

         exit();

     }

 #   ifdef DEBUG

     printf("Get_args, nThread%2d n %d n_steps %d delta_t %e output_freq %d g_i %c\n",

         *thread_count_p, *n_p, *n_steps_p, *delta_t_p, *output_freq_p, *g_i_p);

     fflush(stdout);

 #   endif

 }

 void Gen_init_cond(struct particle_s curr[], int n)

 {

     const double mass = 5.0e24, gap = 1.0e5, speed = 3.0e4;

     //srand(2);

     for (int i = ; i < n; i++)

     {

         curr[i].m = mass;

         curr[i].s[X] = i * gap;

         curr[i].s[Y] = 0.0;

         curr[i].v[X] = 0.0;

         // vel[i][Y] = speed * (2 * rand() / (double)RAND_MAX) - 1);

         curr[i].v[Y] = (i % ) ? -speed : speed;

     }

 }

 void Get_init_cond(struct particle_s curr[], int n)

 {

     printf("For each particle, enter (in order): mass x-coord y-coord x-velocity y-velocity\n");

     for (int i = ; i < n; i++)

     {

         scanf_s("%lf", &curr[i].m);

         scanf_s("%lf", &curr[i].s[X]);

         scanf_s("%lf", &curr[i].s[Y]);

         scanf_s("%lf", &curr[i].v[X]);

         scanf_s("%lf", &curr[i].v[Y]);

     }

 }

 void Output_state(double time, struct particle_s curr[], int n)

 {

     printf("Output_state, time = %.2f\n", time);

     for (int i = ; i < n; i++)

         printf("%2d %10.3e %10.3e %10.3e %10.3e %10.3e\n", i, curr[i].m, curr[i].s[X], curr[i].s[Y], curr[i].v[X], curr[i].v[Y]);

     printf("\n");

     fflush(stdout);

 }

 void Compute_force(int part, vect_t forces[], struct particle_s curr[], int n)

 {

     int k;

     vect_t f_part_k;

     double len, fact;

     for (forces[part][X] = forces[part][Y] = 0.0, k = ; k < n; k++)

     {

         if (k != part)

         {

             f_part_k[X] = curr[part].s[X] - curr[k].s[X];

             f_part_k[Y] = curr[part].s[Y] - curr[k].s[Y];

             len = sqrt(f_part_k[X] * f_part_k[X] + f_part_k[Y] * f_part_k[Y]);

             fact = -G * curr[part].m * curr[k].m / (len * len * len);

             f_part_k[X] *= fact;

             f_part_k[Y] *= fact;

             forces[part][X] += f_part_k[X];

             forces[part][Y] += f_part_k[Y];

 #           ifdef DEBUG

             printf("Compute_force, %d, %2d> %10.3e %10.3e %10.3e %10.3e\n", k, len, fact, f_part_k[X], f_part_k[Y]);

             fflush(stdout);

 #           endif

         }

     }

 }

 void Update_part(int part, vect_t forces[], struct particle_s curr[], int n, double delta_t)

 {

     const double fact = delta_t / curr[part].m;

 #   ifdef DEBUG

     printf("Update_part before, part%2d %10.3e %10.3e %10.3e %10.3e %10.3e %10.3e\n",

         part, curr[part].s[X], curr[part].s[Y], curr[part].v[X], curr[part].v[Y], forces[part][X], forces[part][Y]);

     fflush(stdout);

 #   endif

     curr[part].s[X] += delta_t * curr[part].v[X];

     curr[part].s[Y] += delta_t * curr[part].v[Y];

     curr[part].v[X] += fact * forces[part][X];

     curr[part].v[Y] += fact * forces[part][Y];

 #  ifdef DEBUG

     printf("Update_part after, part%2d %10.3e %10.3e %10.3e %10.3e)\n",

         part, curr[part].s[X], curr[part].s[Y], curr[part].v[X], curr[part].v[Y]);

 #  endif

 }

 void Compute_energy(struct particle_s curr[], int n, double* kin_en_p, double* pot_en_p)// 计算系统轨道能量，没用到

 {

     int i, j;

     vect_t diff;

     double temp;

     for (i = , temp = 0.0; i < n; temp += curr[i].m * curr[i].v[X] * curr[i].v[X] + curr[i].v[Y] * curr[i].v[Y], i++);

     *kin_en_p = temp * 0.5;

     for (i = , temp = .; i < n - ; i++)

     {

         for (j = i + ; j < n; j++)

         {

             diff[X] = curr[i].s[X] - curr[j].s[X];

             diff[Y] = curr[i].s[Y] - curr[j].s[Y];

             temp += -G * curr[i].m * curr[j].m / sqrt(diff[X] * diff[X] + diff[Y] * diff[Y]);

         }

     }

     *pot_en_p = temp;

 }

 int main(int argc, char* argv[])

 {

     int n, part;

     int n_steps, step;

     double delta_t;

     int output_freq;

     struct particle_s* curr;    // 颗粒信息

     vect_t* forces;             // 引力信息

     int thread_count;           // 线程数，用于函数参数和 omp 子句，不是全局变量

     char g_i;

     double start, finish;

     Get_args(argc, argv, &thread_count, &n, &n_steps, &delta_t, &output_freq, &g_i);

     curr = (particle_s*)malloc(n * sizeof(struct particle_s));

     forces = (vect_t*)malloc(n * sizeof(vect_t));

     if (g_i == 'g')

         Gen_init_cond(curr, n);

     else

         Get_init_cond(curr, n);

     start = omp_get_wtime();

 #   ifdef OUTPUT

     Output_state(, curr, n);

 #   endif

 #   pragma omp parallel num_threads(thread_count) default(none) shared(curr, forces, thread_count, delta_t, n, n_steps, output_freq) private(step, part)

     for (step = ; step <= n_steps; step++)

     {

         // memset(forces, 0, n*sizeof(vect_t));

 #       pragma omp for

         for (part = ; part < n; part++)

             Compute_force(part, forces, curr, n);

 #       pragma omp for

         for (part = ; part < n; part++)

             Update_part(part, forces, curr, n, delta_t);

 #       ifdef OUTPUT

 #       pragma omp single

         if (step % output_freq == )

             Output_state(step * delta_t, curr, n);

 #       endif

     }

     finish = omp_get_wtime();

     printf("Elapsed time = %e ms\n", (finish - start) * );

     free(curr);

     free(forces);

     return ;

 }

● 输出结果。8 进程 16 体，3 秒，时间步长 1 秒，舍去 debug 输出  1.094827e+01 ms；8 进程 1024 体，3600 秒，时间步长 1 秒，舍去 output 和 debug 输出 1.485764e+04 ms

D:\Code\OpenMP\OpenMPProjectTemp\x64\Debug>OpenMPProjectTemp.exe      g

Output_state, time = 1.00

   5.000e+24  0.000e+00  3.000e+04  5.273e+04  3.000e+04

   5.000e+24  1.000e+05 -3.000e+04  1.922e+04 -3.000e+04

   5.000e+24  2.000e+05  3.000e+04  1.071e+04  3.000e+04

   5.000e+24  3.000e+05 -3.000e+04  6.802e+03 -3.000e+04

   5.000e+24  4.000e+05  3.000e+04  4.485e+03  3.000e+04

   5.000e+24  5.000e+05 -3.000e+04  2.875e+03 -3.000e+04

   5.000e+24  6.000e+05  3.000e+04  1.614e+03  3.000e+04

   5.000e+24  7.000e+05 -3.000e+04  5.213e+02 -3.000e+04

   5.000e+24  8.000e+05  3.000e+04 -5.213e+02  3.000e+04

   5.000e+24  9.000e+05 -3.000e+04 -1.614e+03 -3.000e+04

  5.000e+24  1.000e+06  3.000e+04 -2.875e+03  3.000e+04

  5.000e+24  1.100e+06 -3.000e+04 -4.485e+03 -3.000e+04

  5.000e+24  1.200e+06  3.000e+04 -6.802e+03  3.000e+04

  5.000e+24  1.300e+06 -3.000e+04 -1.071e+04 -3.000e+04

  5.000e+24  1.400e+06  3.000e+04 -1.922e+04  3.000e+04

  5.000e+24  1.500e+06 -3.000e+04 -5.273e+04 -3.000e+04

Output_state, time = 2.00

   5.000e+24  5.273e+04  6.000e+04  9.288e+04  1.641e+04

   5.000e+24  1.192e+05 -6.000e+04  3.818e+04 -3.791e+03

   5.000e+24  2.107e+05  6.000e+04  2.116e+04  3.791e+03

   5.000e+24  3.068e+05 -6.000e+04  1.356e+04 -3.101e+03

   5.000e+24  4.045e+05  6.000e+04  8.930e+03  3.101e+03

   5.000e+24  5.029e+05 -6.000e+04  5.739e+03 -2.959e+03

   5.000e+24  6.016e+05  6.000e+04  3.218e+03  2.959e+03

   5.000e+24  7.005e+05 -6.000e+04  1.043e+03 -2.929e+03

   5.000e+24  7.995e+05  6.000e+04 -1.043e+03  2.929e+03

   5.000e+24  8.984e+05 -6.000e+04 -3.218e+03 -2.959e+03

  5.000e+24  9.971e+05  6.000e+04 -5.739e+03  2.959e+03

  5.000e+24  1.096e+06 -6.000e+04 -8.930e+03 -3.101e+03

  5.000e+24  1.193e+06  6.000e+04 -1.356e+04  3.101e+03

  5.000e+24  1.289e+06 -6.000e+04 -2.116e+04 -3.791e+03

  5.000e+24  1.381e+06  6.000e+04 -3.818e+04  3.791e+03

  5.000e+24  1.447e+06 -6.000e+04 -9.288e+04 -1.641e+04

Output_state, time = 3.00

   5.000e+24  1.456e+05  7.641e+04  1.273e+05 -1.575e+03

   5.000e+24  1.574e+05 -6.379e+04  5.867e+04  2.528e+04

   5.000e+24  2.319e+05  6.379e+04  2.685e+04 -2.069e+04

   5.000e+24  3.204e+05 -6.310e+04  1.884e+04  2.228e+04

   5.000e+24  4.134e+05  6.310e+04  1.235e+04 -2.151e+04

   5.000e+24  5.086e+05 -6.296e+04  8.111e+03  2.179e+04

   5.000e+24  6.048e+05  6.296e+04  4.537e+03 -2.163e+04

   5.000e+24  7.016e+05 -6.293e+04  1.493e+03  2.169e+04

   5.000e+24  7.984e+05  6.293e+04 -1.493e+03 -2.169e+04

   5.000e+24  8.952e+05 -6.296e+04 -4.537e+03  2.163e+04

  5.000e+24  9.914e+05  6.296e+04 -8.111e+03 -2.179e+04

  5.000e+24  1.087e+06 -6.310e+04 -1.235e+04  2.151e+04

  5.000e+24  1.180e+06  6.310e+04 -1.884e+04 -2.228e+04

  5.000e+24  1.268e+06 -6.379e+04 -2.685e+04  2.069e+04

  5.000e+24  1.343e+06  6.379e+04 -5.867e+04 -2.528e+04

  5.000e+24  1.354e+06 -7.641e+04 -1.273e+05  1.575e+03

Elapsed time = 1.094827e-02 seconds

● 简化算法

 // omp_nbody_red.c，OpenMP 简化算法

 #include <stdio.h>

 #include <stdlib.h>

 #include <string.h>

 #include <math.h>

 #include <omp.h>

 #define OUTPUT

 //#define DEBUG

 #define DIM     2

 #define X       0

 #define Y       1

 typedef double vect_t[DIM];

 const double G = 6.673e-11;

 struct particle_s

 {

     double m;

     vect_t s;

     vect_t v;

 };

 void Usage(char* prog_name)

 {

     fprintf(stderr, "usage: %s <nThreads> <nParticles> <nTimestep> <sizeTimestep> <outputFrequency> <g|i>\n", prog_name);

     fprintf(stderr, "    'g': inite condition by random\n    'i': inite condition from stdin\n");

     exit();

 }

 void Get_args(int argc, char* argv[], int* thread_count_p, int* n_p, int* n_steps_p, double* delta_t_p, int* output_freq_p, char* g_i_p)

 {

     if (argc != )

         Usage(argv[]);

     *thread_count_p = strtol(argv[], NULL, );

     *n_p = strtol(argv[], NULL, );

     *n_steps_p = strtol(argv[], NULL, );

     *delta_t_p = strtod(argv[], NULL);

     *output_freq_p = strtol(argv[], NULL, );

     *g_i_p = argv[][];

     if (*thread_count_p <  || *n_p <=  || *n_p % *thread_count_p || *n_steps_p <  || *delta_t_p <=  || *g_i_p != 'g' && *g_i_p != 'i')

     {

         Usage(argv[]);

         exit();

     }

 #   ifdef DEBUG

     printf("Get_args, nThread%2d n %d n_steps %d delta_t %e output_freq %d g_i %c\n",

         *thread_count_p, *n_p, *n_steps_p, *delta_t_p, *output_freq_p, *g_i_p);

     fflush(stdout);

 #   endif

 }

 void Gen_init_cond(struct particle_s curr[], int n)

 {

     const double mass = 5.0e24, gap = 1.0e5, speed = 3.0e4;

     //srand(2);

     for (int i = ; i < n; i++)

     {

         curr[i].m = mass;

         curr[i].s[X] = i * gap;

         curr[i].s[Y] = 0.0;

         curr[i].v[X] = 0.0;

         // vel[i][Y] = speed * (2 * rand() / (double)RAND_MAX) - 1);

         curr[i].v[Y] = (i % ) ? -speed : speed;

     }

 }

 void Get_init_cond(struct particle_s curr[], int n)

 {

     printf("For each particle, enter (in order): mass x-coord y-coord x-velocity y-velocity\n");

     for (int i = ; i < n; i++)

     {

         scanf_s("%lf", &curr[i].m);

         scanf_s("%lf", &curr[i].s[X]);

         scanf_s("%lf", &curr[i].s[Y]);

         scanf_s("%lf", &curr[i].v[X]);

         scanf_s("%lf", &curr[i].v[Y]);

     }

 }

 void Output_state(double time, struct particle_s curr[], int n)

 {

     printf("Output_state, time = %.2f\n", time);

     for (int i = ; i < n; i++)

         printf("%2d %10.3e %10.3e %10.3e %10.3e %10.3e\n", i, curr[i].m, curr[i].s[X], curr[i].s[Y], curr[i].v[X], curr[i].v[Y]);

     printf("\n");

     fflush(stdout);

 }

 void Compute_force(int part, vect_t forces[], struct particle_s curr[], int n)

 {

     vect_t f_part_k;

     double len, fact;

     for (int k = part + ; k < n; k++)

     {

         f_part_k[X] = curr[part].s[X] - curr[k].s[X];

         f_part_k[Y] = curr[part].s[Y] - curr[k].s[Y];

         len = sqrt(f_part_k[X] * f_part_k[X] + f_part_k[Y] * f_part_k[Y]);

         fact = -G * curr[part].m * curr[k].m / (len * len * len);

         f_part_k[X] *= fact;

         f_part_k[Y] *= fact;

         forces[part][X] += f_part_k[X]; // 靠前的颗粒加上本次计算结果的相反数

         forces[part][Y] += f_part_k[Y];

         forces[k][X] -= f_part_k[X];    // 靠后的颗粒加上本次计算结果

         forces[k][Y] -= f_part_k[Y];

 #       ifdef DEBUG

         printf("Compute_force, k%2d> %10.3e %10.3e %10.3e %10.3e\n", k, len, fact, f_part_k[X], f_part_k[Y]);

 #       endif

     }

 }

 void Update_part(int part, vect_t forces[], struct particle_s curr[], int n, double delta_t)

 {

     const double fact = delta_t / curr[part].m;

 #   ifdef DEBUG

     printf("Update_part before, part%2d %10.3e %10.3e %10.3e %10.3e %10.3e %10.3e\n",

         part, curr[part].s[X], curr[part].s[Y], curr[part].v[X], curr[part].v[Y], forces[part][X], forces[part][Y]);

     fflush(stdout);

 #   endif

     curr[part].s[X] += delta_t * curr[part].v[X];

     curr[part].s[Y] += delta_t * curr[part].v[Y];

     curr[part].v[X] += fact * forces[part][X];

     curr[part].v[Y] += fact * forces[part][Y];

 #  ifdef DEBUG

     printf("Update_part after, part%2d %10.3e %10.3e %10.3e %10.3e)\n",

         part, curr[part].s[X], curr[part].s[Y], curr[part].v[X], curr[part].v[Y]);

 #  endif

 }

 int main(int argc, char* argv[])

 {

     int n, part;

     int n_steps, step;

     double delta_t;

     int output_freq;

     struct particle_s* curr;        // 颗粒信息

     vect_t* forces;                 // 引力信息

     int nThread, thread, my_rank;   // 线程数，用于函数参数和 omp 子句，不是全局变量，当前线程编号（循环变量）

     char g_i;

     double start, finish;

     vect_t* loc_forces;             // 每个线程局部引力

     Get_args(argc, argv, &nThread, &n, &n_steps, &delta_t, &output_freq, &g_i);

     curr = (particle_s*)malloc(n * sizeof(struct particle_s));

     forces = (vect_t*)malloc(n * sizeof(vect_t));

     loc_forces = (vect_t*)malloc(nThread*n * sizeof(vect_t));

     if (g_i == 'g')

         Gen_init_cond(curr, n);

     else

         Get_init_cond(curr, n);

     start = omp_get_wtime();

 #   ifdef OUTPUT

     Output_state(, curr, n);

 #   endif

 #   pragma omp parallel num_threads(nThread) default(none) shared(curr, forces, nThread, delta_t, n, n_steps, output_freq, loc_forces) private(step, part,thread, my_rank)

     {

         my_rank = omp_get_thread_num();

         for (step = ; step <= n_steps; step++)

         {

             // memset(loc_forces + my_rank*n, 0, n*sizeof(vect_t));

 #           pragma omp for

             for (part = ; part < nThread * n; part++)

                 loc_forces[part][X] = loc_forces[part][Y] = 0.0;

 #           pragma omp for schedule(static, )  // 注意使用循环调度

             for (part = ; part < n - ; part++)

                 Compute_force(part, loc_forces + my_rank * n, curr, n);

 #           pragma omp for

             for (part = ; part < n; part++)    // 计算引力

             {

                 forces[part][X] = forces[part][Y] = 0.0;

                 for (thread = ; thread < nThread; thread++)

                 {

                     forces[part][X] += loc_forces[thread * n + part][X];

                     forces[part][Y] += loc_forces[thread * n + part][Y];

                 }

             }

 #           pragma omp for

             for (part = ; part < n; part++)    // 更新位置

                 Update_part(part, forces, curr, n, delta_t);

 #           ifdef OUTPUT

             if (step % output_freq == )

             {

 #               pragma omp single

                 Output_state(step*delta_t, curr, n);

             }

 #           endif

         }

     }

     finish = omp_get_wtime();

     printf("Elapsed time = %e ms\n", (finish - start) * );

     free(curr);

     free(forces);

     free(loc_forces);

     return ;

 }

● 输出结果，与基本算法类似。8 进程 16 体，3 秒，时间步长 1 秒，舍去 debug 输出 9.887694e-00 ms；8 进程 1024 体，3600 秒，时间步长 1 秒，舍去 output 和 debug 输出 7.857710e+03 ms。数据规模扩大后计算时间趋近基本算法的一半，说明计算花费时间较多，而数据传输花费时间较少。

OpenMP n 体问题的更多相关文章

  1. Pthreads n 体问题

    ▶ <并行程序设计导论>第六章中讨论了 n 体问题,分别使用了 MPI,Pthreads,OpenMP 来进行实现,这里是 Pthreads 的代码,分为基本算法和简化算法(引力计算量为基 ...

  2. MPI n 体问题

    ▶ <并行程序设计导论>第六章中讨论了 n 体问题,分别使用了 MPI,Pthreads,OpenMP 来进行实现,这里是 MPI 的代码,分为基本算法和简化算法(引力计算量为基本算法的一 ...

  3. 应用OpenMP的一个简单的设计模式

    小喵的唠叨话:最近很久没写博客了,一是因为之前写的LSoftmax后馈一直没有成功,所以在等作者的源码.二是最近没什么想写的东西.前两天,在预处理图片的时候,发现处理200w张图片,跑了一晚上也才处理 ...

  4. openmp 的使用

    http://blog.csdn.net/gengshenghong/article/details/7003110 说明:这部分内容比较基础,主要是分析几个容易混淆的OpenMP函数,加以理解. ( ...

  5. OpenMP编程总结表

    本文对OpenMP 2.0的全部语法——Macro(宏定义).Environment Variables(环境变量).Data Types(数据类型).Compiler Directives(编译指导 ...

  6. OpenMP共享内存并行编程详解

    实验平台:win7, VS2010 1. 介绍 平行计算机可以简单分为共享内存和分布式内存,共享内存就是多个核心共享一个内存,目前的PC就是这类(不管是只有一个多核CPU还是可以插多个CPU,它们都有 ...

  7. OpenMP并行构造的schedule子句详解 (转载)

    原文:http://blog.csdn.net/gengshenghong/article/details/7000979 schedule的语法为: schedule(kind, [chunk_si ...

  8. 利用OpenMP实现埃拉托斯特尼（Eratosthenes）素数筛法并行化 分类： 算法与数据结构 2015-05-09 12:24 157人阅读 评论(0) 收藏

    1.算法简介 1.1筛法起源 筛法是一种简单检定素数的算法.据说是古希腊的埃拉托斯特尼(Eratosthenes,约公元前274-194年)发明的,又称埃拉托斯特尼筛法(sieve of Eratos ...

  9. 大数据并行计算利器之MPI/OpenMP

    大数据集群计算利器之MPI/OpenMP ---以连通域标记算法并行化为例 1 背景 图像连通域标记算法是从一幅栅格图像(通常为二值图像)中,将互相邻接(4邻接或8邻接)的具有非背景值的像素集合提取出 ...

随机推荐

  1. 《Effective C#》读书笔记——条目13:正确地初始化静态成员变量<.NET资源管理>

      我们知道在C#语言中创建一个类型的实例前,就应该初始化该类型的所有静态成员变量.C#语言为我们提供了静态初始化器和静态构造函数.其中,静态构造函数是一个特殊的构造函数,将在其他所有方法执行前以及变 ...

  2. Android 各API版本代码常量

    Android开发中常常有版本比较这个功能,来做版本兼容或者,其他相关效果等   以下是Android 7.0版本下的源码:   public static class VERSION_CODES { ...

  3. HDU 4522 (恶心建图)

    湫湫系列故事——过年回家 Time Limit: 500/200 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)Total ...

  4. UVA-10806 Dijkstra, Dijkstra. （最小费用流，网络流建模）

    题目大意:给一张带权简单图,找出一条经过起点s和终点t的最小回路. 题目分析:建立网络,以s为源点,t为汇点,另每条边的容量为1,单位费用为边权值.求最小费用流,增广两次后的最小费用便是答案. 代码如 ...

  5. 99. Recover Binary Search Tree -- 找到二叉排序树中交换过位置的两个节点

    Two elements of a binary search tree (BST) are swapped by mistake. Recover the tree without changing ...

  6. python学习笔记（三）---python关键字及其用法

    转载出处:https://www.cnblogs.com/ECJTUACM-873284962/p/7576959.html 前言 最近在学习Java Sockst的时候遇到了一些麻烦事,我觉得我很有 ...

  7. hdu2883

    题解: 网络流 用一个离散化 代码: #include<cstdio> #include<cstring> #include<algorithm> using na ...

  8. windows下搭建nginx+php+虚拟主机配置过程

    需要软件信息: nginx php RunHiddenConsole 首先安装之前要规划一下把他们放到那里,比如我将他们统一放在e :/web下 那么将这些都拷贝过来,开始吧,window要执行php ...

  9. 学习ThinkPHP第一天

    今天开始学习PHP框架了,刚开始学,感觉挺兴奋的,离自己建立自己的博客又仅了一步,在linux环境下配置一定要赋予新创建的文件夹权限: sudo chmod -R 0777   filePath 这样 ...

  10. [BZOJ5312]冒险

    bzoj CSAcademy description 一个序列\(a_i\),支持区间与一个数,区间或一个数,求区间最大值. \(n,m\le2\times10^5\) sol 线段树每个节点上维护区 ...