数学研发论坛

 找回密码
 欢迎注册
查看: 8736|回复: 33

[擂台] A075464

[复制链接]
发表于 2014-3-20 21:49:39 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能,让你轻松玩转社区。

您需要 登录 才可以下载或查看,没有帐号?欢迎注册

x
https://oeis.org/A075464。复杂度取决于解空间的维数。现在这个序列已经算到帝第60项,是因为下一个达到40维。我们需要穷举2^40个解,

这个问题为关灯问题,对于n*n的电灯阵列,每关开关一个灯都会改变上下左右相邻灯的状态。如果开始所有灯开着,目标是关掉所有的灯,解必然存在,但是可能不唯一,这个序列就是要找到开关次数最小的解。
而对于n*n问题存在一些变开关方案保持所有灯状态不变,它们构成二阶域上线性空间。所以对于本题,求出任意一个特解,以及这个线性空间一组基后,就可以穷举所有解找出最优解了
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2014-3-20 22:04:43 | 显示全部楼层
现在序列以已经算到第60项,因为下一个是40维,也就是需要穷举2^40个解,每个需要算40个长为三千多比特向量的异或并数结果1的数目。如果采用递归估计可以减少为三平均三次,由于一个时钟可操作32比特,平均300时钟可处理一个数,所以应该还属于可以忍受的计算量
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2014-3-20 22:13:56 | 显示全部楼层
我的csdn博客里面有穷举算法,但是效率很低,可以作为参考

http://blog.csdn.net/mathe/article/details/1143634
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2014-3-21 14:17:41 | 显示全部楼层
  1. /*The code to turn off all bulbs in a matrix of bulbs
  2. */

  3. #include <stdio.h>
  4. #include <intrin.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #define N 10000
  8. typedef char ** MATRIX;
  9. typedef char * VECTOR;
  10. typedef char *const* CONST_MATRIX;
  11. typedef const char * CONST_VECTOR;

  12. MATRIX matrix_alloc2(int n, int m){
  13.         MATRIX x= (MATRIX)malloc(sizeof(char *)*n+sizeof(char)*n*m);
  14.         int i;
  15.         x[0]=(char *)(x+n);
  16.         for(i=1;i<n;i++)x[i]=x[i-1]+m;
  17.         return x;
  18. }

  19. int maxtrix_count_one(MATRIX x,int n, int m){
  20.         int r=0;
  21.         int i,j;
  22.         for(i=0;i<n;i++)for(j=0;j<n;j++)if(x[i][j]!=0)r++;
  23.         return r;
  24. }

  25. MATRIX matrix_alloc(int n){
  26.     MATRIX x = (MATRIX)malloc(sizeof(char *)*n+sizeof(char)*n*n);
  27.     int i;
  28.     x[0]=(char *)(x+n);
  29.     for(i=1;i<n;i++)x[i]=x[i-1]+n;
  30.     return x;
  31. }

  32. void matrix_free(MATRIX x){
  33.     free(x);
  34. }

  35. VECTOR vector_alloc(int n){
  36.     VECTOR x = (VECTOR)malloc(sizeof(char)*n);
  37.     return x;
  38. }

  39. void vector_free(VECTOR x){
  40.     free(x);
  41. }

  42. void matrix_sum(MATRIX A, CONST_MATRIX B, int n){
  43.     int i,j;
  44.     for(i=0;i<n;i++){
  45.         for(j=0;j<n;j++){
  46.             A[i][j] ^= B[i][j];
  47.         }
  48.     }
  49. }

  50. void vector_sum(VECTOR a, CONST_VECTOR b, int n){
  51.     int i;
  52.     for(i=0;i<n;i++)a[i]^=b[i];
  53. }

  54. void matrix_mul(MATRIX out, CONST_MATRIX in1, CONST_MATRIX in2, int n){
  55.     int i,j,k;
  56.     for(i=0;i<n;i++)for(j=0;j<n;j++){
  57.         int sum=0;
  58.         for(k=0;k<n;k++){
  59.             if(in1[i][k])
  60.                 sum^=in2[k][j];
  61.         }
  62.         out[i][j]=sum;
  63.     }
  64. }

  65. void matrix_mul_H(MATRIX out, CONST_MATRIX in, int n){
  66.     int i,j;
  67.     for(i=0;i<n;i++)for(j=0;j<n;j++){
  68.         int sum=in[i][j];
  69.         if(i>0)sum^=in[i-1][j];
  70.         if(i<n-1)sum^=in[i+1][j];
  71.         out[i][j]=sum;
  72.     }
  73. }

  74. void matrix_mul_vector(VECTOR out, CONST_MATRIX m, CONST_VECTOR in, int n){
  75.     int i,j;
  76.     for(i=0;i<n;i++){
  77.         int sum=0;
  78.         for(j=0;j<n;j++){
  79.             sum^=m[i][j]&in[j];
  80.         }
  81.         out[i]=sum;
  82.     }
  83. }

  84. void H_mul_vector(VECTOR out, CONST_VECTOR in, int n){
  85.     int i;
  86.     for(i=0;i<n;i++){
  87.         int sum=in[i];
  88.         if(i>0)sum^=in[i-1];
  89.         if(i<n-1)sum^=in[i+1];
  90.         out[i]=sum;
  91.     }
  92. }

  93. void vector_init_const(VECTOR v, char c, int n){
  94.     int i;
  95.     for(i=0;i<n;i++)v[i]=c;
  96. }

  97. void matrix_init_O(MATRIX o, int n){
  98.     int i,j;
  99.     for(i=0;i<n;i++)for(j=0;j<n;j++)o[i][j]=0;
  100. }

  101. void matrix_init_const(MATRIX m, char c, int n1, int n2){
  102.     int i,j;
  103.     for(i=0;i<n1;i++)for(j=0;j<n2;j++)m[i][j]=c;
  104. }

  105. void matrix_init_E(MATRIX e, int n){
  106.     int j;
  107.     matrix_init_O(e,n);
  108.     for(j=0;j<n;j++)e[j][j]=1;
  109. }

  110. void matrix_init_H(MATRIX h, int n){
  111.     int i;
  112.     matrix_init_O(h,n);
  113.     for(i=0;i<n;i++){
  114.         if(i>=1)h[i][i-1]=1;
  115.         h[i][i]=1;
  116.         if(i<n-1)h[i][i+1]=1;
  117.     }
  118. }

  119. void matrix_copy(MATRIX m, CONST_MATRIX k, int n){
  120.     int i,j;
  121.     for(i=0;i<n;i++)for(j=0;j<n;j++)m[i][j]=k[i][j];
  122. }

  123. void matrix_copy2(MATRIX m, CONST_MATRIX k, int n1, int n2){
  124.     int i,j;
  125.     for(i=0;i<n1;i++)for(j=0;j<n2;j++)m[i][j]=k[i][j];
  126. }

  127. void vector_copy(VECTOR v, CONST_VECTOR w, int n){
  128.     int i;
  129.     for(i=0;i<n;i++)v[i]=w[i];
  130. }

  131. void matrix_output2(CONST_MATRIX m, int n1, int n2){
  132.     int i,j;
  133.     for(i=0;i<n1;i++){
  134.         for(j=0;j<n2;j++){
  135.             printf("%d",m[i][j]);
  136.         }
  137.         printf("\n");
  138.     }
  139. }

  140. void matrix_output(CONST_MATRIX m, int n){
  141.     int i,j;
  142.     for(i=0;i<n;i++){
  143.         for(j=0;j<n;j++){
  144.             printf("%d",m[i][j]);
  145.         }
  146.         printf("\n");
  147.     }
  148. }
  149. void vector_output(VECTOR v, int n){
  150.     int i;
  151.     for(i=0;i<n;i++)printf("%d",v[i]);
  152.     printf("\n");
  153. }

  154. void Usage(const char *program_name){
  155.     printf("Usage:\n");
  156.     printf("\t$%s n\n",program_name);
  157.     printf("\t\twhere n is a positive integer no more than %d\n", N);
  158.     printf("Or\n");
  159.     printf("\t$%s [0|1]* [0|1]* ... [0|1]*\n", program_name);
  160.     printf("\t\tIn this format, there're total n strings of 0 and 1 and length of all 01 strings are same\n");
  161.     printf("The program assumes there're an n*m array. Each cell in the array has a switch "
  162.         "and a light. On touches of the switch in a cell will changes the state of the "
  163.         "light in the cell as well as the lights in the neighbors of the cell, so that "
  164.         "one switch could change states of 5 lights at most\n");
  165.     printf("The program will try to find a solution to turn all lights off\n");
  166.     printf("The first format of input gives an initial n*n array with all lights on\n");
  167.     printf("The second format requires n strings of 0 and 1, and the length of all strings"
  168.         " are m. Each string is correspondent to state of lights in one line of the "
  169.         "array. A digit 0 means the correspondent light is off and 1 means the light is "
  170.         "on.\n");
  171.     printf("The program will output an n*m matrix of 0 and 1 when there's a solution which "
  172.         "tells whether we need to touch a switch to turn off all the lights\nOr the "
  173.         "program will output "NO SOLUTION" when there's no solution\n");
  174.     exit(-1);
  175. }

  176. MATRIX P0,P1,H;
  177. VECTOR ME;
  178. MATRIX init;

  179. static void copy_matrix_to_bit_string(MATRIX x, int m, int n, unsigned long long *bitstrings, int ll_len)
  180. {
  181.     int i,j;
  182.     memset(bitstrings, 0, ll_len*sizeof(unsigned long long));
  183.     for(i=0;i<n;i++){
  184.          for(j=0;j<m;j++){
  185.             if(x[i][j]!=0){
  186.                int index=i*m+j;
  187.                int word = index/64;
  188.                int off = index%64;
  189.                bitstrings[word]|=1ll<<off;
  190.             }
  191.          }
  192.     }
  193. }

  194. int count_one(const unsigned long long *x, int ll_len)
  195. {
  196.    int r=0;
  197.    int i;
  198.    const unsigned int *p=(const unsigned int*)x;
  199.    for(i=0;i<2*ll_len;i++)r+=_mm_popcnt_u32(p[i]);
  200.    return r;
  201. }

  202. static void llxor(unsigned long long *r,  const unsigned long long *x, int ll_len)
  203. {
  204.     int i;
  205.     for(i=0;i<ll_len;i++)r[i]^=x[i];
  206. }


  207. void search_base_result(const unsigned long long *any_root, const unsigned long long *base, int base_count, int ll_len)
  208. {
  209.     long long x;
  210.     int j;
  211.     unsigned long long *best_r = (unsigned long long *)malloc(ll_len*sizeof(unsigned long long));
  212.     unsigned long long *cur_r = (unsigned long long *)malloc(ll_len*sizeof(unsigned long long));
  213.     int best_count = count_one(any_root, ll_len);
  214.     memcpy(best_r, any_root, ll_len*sizeof(unsigned long long));
  215.     memcpy(cur_r, any_root, ll_len*sizeof(unsigned long long));
  216.     for(x=1LL;x<=(1LL<<base_count)-1;x++){
  217.        for(j=0;j<base_count&&(x&(1LL<<j))==0;j++){
  218.           llxor(cur_r, base+j*ll_len, ll_len);
  219.        }
  220.        llxor(cur_r, base+j*ll_len, ll_len);
  221.        int cur_count = count_one(cur_r, ll_len);
  222.        if(cur_count<best_count){
  223.            best_count = cur_count;
  224.            memcpy(best_r, cur_r, ll_len*sizeof(unsigned long long));
  225.        }
  226.     }
  227.     free(best_r);
  228.     free(cur_r);
  229.     printf("best count:%d\n",best_count);
  230. }

  231. //First we need to solve equation P*X(n) = ME;
  232. //There could be multiple solutions
  233. //For each solution X(n), try
  234. //X(n-1) = INIT+ H*X(n);
  235. //X(K)   = INIT + H*X(k+1)+X(k+2);//for k<n-1
  236. void Solve(MATRIX P, VECTOR ME, int n, int m)
  237. {
  238.     int *freedom_index;
  239.     int freedom_count=0;
  240.     int i,j,k,t;
  241.     int failed=0;
  242.     int longlong_len = (n*m+63)/64;
  243.     freedom_index = (int *)malloc(sizeof(int)*m);
  244.     //First solve equition P*X(n) = ME
  245.     for(i=0,t=0;i<m;i++){
  246.         for(j=t;j<m;j++)if(P[j][i]==1)break;
  247.         if(j==m){
  248.             //find a freedom factor
  249.             freedom_index[freedom_count++]=i;
  250.         }else{
  251.             if(j!=t){
  252.                 //Swap line j and t
  253.                 int temp;
  254.                 for(k=i;k<m;k++){
  255.                     temp=P[t][k];
  256.                     P[t][k]=P[j][k];
  257.                     P[j][k]=temp;
  258.                 }
  259.                 temp = ME[t];
  260.                 ME[t] = ME[j];
  261.                 ME[j] = temp;
  262.             }
  263.             for(j=0;j<m;j++){
  264.                 if(j!=t&&P[j][i]){
  265.                     //If P[j][i] is 1, add Line i into Line j
  266.                     for(k=i;k<m;k++){
  267.                         P[j][k]^=P[t][k];
  268.                     }
  269.            
复制代码
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2014-3-21 14:56:03 | 显示全部楼层
  1.                     ME[j]^=ME[t];
  2.                 }
  3.             }
  4.                         t++;
  5.         }
  6.     }
  7.         for(;t<m;t++){
  8.                 if(ME[t]!=0){
  9.                         failed=1;
  10.                         break;
  11.                 }
  12.         }
  13.     fprintf(stderr,"Freedom factor = %d\n", freedom_count);
  14.     if(failed){
  15.         printf("NO SOLUTION\n");
  16.         free(freedom_index);
  17.         return;
  18.     }
  19.         if(freedom_count>0){
  20.                 int delta=freedom_count;
  21.                 for(k=m-1,t=freedom_count-1;k>=0&&delta>0;k--){
  22.                         if(k==freedom_index[t]){
  23.                                 int i;
  24.                                 for(i=0;i<m;i++)P[k][i]=0;
  25.                                 ME[k]=0;
  26.                                 delta--;t--;
  27.                         }else if(delta>0){
  28.                                 for(i=0;i<m;i++)P[k][i]=P[k-delta][i];
  29.                                 ME[k]=ME[k-delta];
  30.                         }
  31.                 }
  32.         }
  33.     //Now ME hold's one solution for X[n],
  34.     //And random reset index inside freedom_index of ME to 0, 1
  35.     //    will result in another solution for X[n];
  36.     //Output one solution
  37. #ifdef _DEBUG
  38.     printf("ME:");vector_output(ME, m);printf("\n");
  39.     printf("H:\n");matrix_output(H,m);
  40.     printf("init:\n");
  41.     matrix_output(init,m);
  42. #endif
  43.     unsigned long long *any_root = (unsigned long long *)malloc(longlong_len*sizeof(unsigned long long));
  44.     unsigned long long *base = (unsigned long long *)malloc(longlong_len *sizeof(unsigned long long) *freedom_count);
  45. //        if(freedom_count>=20)freedom_count=20;//do not search too much, so if the freedom_count is more than 15, the output may not be optimal
  46.         long long u;
  47.         int best_one_count=n*m+1;
  48.         MATRIX bm=matrix_alloc2(n,m);
  49.         for(u=0;u<1LL;u++)//calculate only one roots
  50.     {
  51.         MATRIX x=matrix_alloc2(n,m);
  52.         vector_copy(x[n-1],ME,m);
  53.                 for(k=0;k<freedom_count;k++){
  54.                         if(u&(1<<k)){
  55.                                 x[n-1][freedom_index[k]]=1;
  56.                                 for(i=0;i<m;i++){
  57.                                         if(P[i][freedom_index[k]]!=0){
  58.                                                 x[n-1][i]^=1;
  59.                                         }
  60.                                 }
  61.                         }else{
  62.                                 x[n-1][freedom_index[k]]=0;
  63.                         }
  64.                 }
  65.         matrix_mul_vector(x[n-2],H,x[n-1],m);
  66.         vector_sum(x[n-2],init[n-1],m);
  67.         for(k=n-3;k>=0;k--){
  68.             H_mul_vector(x[k],x[k+1],m);
  69. #ifdef _DEBUG
  70.             printf("x[%d] 1:",k);vector_output(x[k],m);printf("\n");
  71. #endif
  72.             vector_sum(x[k],init[k+1],m);
  73. #ifdef _DEBUG
  74.             printf("x[%d] 2:",k);vector_output(x[k],m);printf("\n");
  75. #endif
  76.             vector_sum(x[k],x[k+2],m);
  77. #ifdef _DEBUG
  78.             printf("x[%d] 3:",k);vector_output(x[k],m);printf("\n");
  79. #endif
  80.         }
  81.         copy_matrix_to_bit_string(x, m, n, any_root, longlong_len);
  82.         matrix_free(x);
  83.     }
  84.     for(u=0;u<freedom_count;u++){
  85.         MATRIX x=matrix_alloc2(n,m);
  86.         for(k=0;k<m;k++)x[n-1][k]=0;
  87.         x[n-1][freedom_index[u]]=1;//only set one value to bit 1
  88.         for(i=0;i<m;i++){
  89.            if(P[i][freedom_index[u]]!=0){
  90.               x[n-1][i]^=1;
  91.            }
  92.         }
  93.         matrix_mul_vector(x[n-2],H,x[n-1],m);
  94.         for(k=n-3;k>=0;k--){
  95.             H_mul_vector(x[k],x[k+1],m);
  96.             vector_sum(x[k],x[k+2],m);
  97.         }
  98.         copy_matrix_to_bit_string(x, m, n, base+u*longlong_len, longlong_len);
  99.         matrix_free(x);
  100.     }
  101.     search_base_result(any_root, base, freedom_count, longlong_len);
  102.     matrix_free(bm);
  103.     free(freedom_index);
  104.     free(any_root);
  105.     free(base);
  106. }

  107. void parse(int argc, char **argv, int *pn,int *pm){
  108.     if(argc == 2){
  109.         int n = atoi(argv[1]);
  110.         if(n<0||n>N){
  111.             Usage(argv[0]);
  112.         }else if(n<=1){
  113.             printf("%d\n",n);
  114.             exit(0);
  115.         }else{
  116.             init=matrix_alloc(n);
  117.             matrix_init_const(init,1,n,n);
  118.                         *pn=*pm=n;
  119.                         return;
  120.         }
  121.         }else if(argc==3){
  122.         int n = atoi(argv[1]);
  123.                 int m = atoi(argv[2]);
  124.         if(n<0||n>N||m<0||m>N){
  125.             Usage(argv[0]);
  126.         }else if(n<=1||m<=1){
  127.             printf("%d\n",n);
  128.             exit(0);
  129.         }else{
  130.             init=matrix_alloc2(n,m);
  131.             matrix_init_const(init,1,n,m);
  132.                         *pn=n;*pm=m;
  133.             return;
  134.         }
  135.         }else{
  136.         int n=argc-1;
  137.         int i,j;
  138.                 int m=strlen(argv[1]);
  139.         init=matrix_alloc2(n,m);
  140.         for(i=0;i<n;i++){
  141.             char *s=argv[i+1];
  142.             if(strlen(s)!=m){
  143.                 matrix_free(init);
  144.                 Usage(argv[0]);
  145.             }
  146.             for(j=0;j<m;j++){
  147.                 if(s[j]!='0'&&s[j]!='1'){
  148.                     matrix_free(init);
  149.                     Usage(argv[0]);
  150.                 }
  151.                 init[i][j]=s[j]-'0';
  152.             }
  153.         }
  154.                 *pm=m;*pn=n;
  155.         return;
  156.     }
  157. }

  158. int main(int argc, char **argv){
  159.     int n,m;
  160.     int i;
  161.     MATRIX temp_matrix;
  162.     VECTOR temp_vector;
  163.     if(argc<2){
  164.         Usage(argv[0]);
  165.     }
  166.     parse(argc,argv,&n,&m);
  167. #ifdef _DEBUG
  168.     printf("Input:\n");
  169.     matrix_output2(init,n,m);
  170. #endif
  171.     ME = vector_alloc(m);
  172.     temp_vector = vector_alloc(m);

  173.     P0 = matrix_alloc(m);
  174.     P1 = matrix_alloc(m);
  175.     H  = matrix_alloc(m);
  176.     temp_matrix = matrix_alloc(m);
  177.     matrix_init_H(H,m);
  178.     matrix_init_E(P0,m);
  179.     matrix_init_H(P1,m);
  180. #ifdef _DEBUG
  181.     printf("P(0):\n");matrix_output(P0,m);
  182.     printf("P(1):\n");matrix_output(P1,m);
  183. #endif

  184.     matrix_mul_vector(ME, P0, init[0], m);
  185.     matrix_mul_vector(temp_vector, P1, init[1], m);
  186. #ifdef _DEBUG
  187.     printf("M(0):");vector_output(ME,m);printf("\n");
  188.     printf("M(1):");vector_output(temp_vector,m);printf("\n");
  189. #endif
  190.     vector_sum(ME,temp_vector,m);
  191. #ifdef _DEBUG
  192.     printf("S(1):");vector_output(ME,m);printf("\n");
  193. #endif

  194.     for(i=2;i<=n;i++){
  195.         matrix_mul_H(temp_matrix,P1,m);
  196.         matrix_sum(temp_matrix,P0,m);//P(k)= H*P(k-1) + P(k-2)
  197.         matrix_copy(P0,P1,m);
  198.         matrix_copy(P1,temp_matrix,m);
  199. #ifdef _DEBUG
  200.         printf("P(%d):\n",i);matrix_output(P1,m);
  201. #endif
  202.         if(i<n){
  203.             matrix_mul_vector(temp_vector, P1, init[i], m);
  204.             vector_sum(ME,temp_vector,m);
  205. #ifdef _DEBUG
  206.             printf("M(%d):",i);vector_output(temp_vector,m);printf("\n");
  207.             printf("S(%d):",i);vector_output(ME,m);printf("\n");
  208. #endif
  209.         }
  210.     }

  211.     Solve(P1, ME, n,m);

  212.     matrix_free(init);
  213.     vector_free(ME);
  214.     vector_free(temp_vector);
  215.     matrix_free(P0);
  216.     matrix_free(P1);
  217.     matrix_free(H);
  218.     matrix_free(temp_matrix);
  219.     return 0;
  220. }
复制代码
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2014-3-21 15:00:39 | 显示全部楼层
android上载代码不是很方便。上面代码计算n=39大概花4分钟,估计n=61大概两天半,n=65大概10天
如果能优化数倍就可以舒服很多了,主要是那个 search_开头的函数
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2014-3-22 20:43:29 来自手机 | 显示全部楼层
发现A075463只计算了29项,其实其计算难度应该不高。上面有个mathematica代码,有了能介绍一下其算法吗?我看不懂。
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2014-3-22 23:05:07 | 显示全部楼层
mathe 发表于 2014-3-22 20:43
发现A075463只计算了29项,其实其计算难度应该不高。上面有个mathematica代码,有了能介绍一下其算法吗?我 ...

mathe都看不明白,我就不去尝试了.
只觉得代码的效率并不高,把16换成19就超级慢了.
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2014-3-23 08:02:49 来自手机 | 显示全部楼层
我是对mathematica不熟悉

点评

可以安装一个Mathematica软件,然后选中对应的函数,查文档. 我相信不难理解的. 我主要是对思路不理解, -_-  发表于 2014-3-23 12:35
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2014-3-23 08:05:06 来自手机 | 显示全部楼层
其实复杂度不比 https://oeis.org/A075462 多多少
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
您需要登录后才可以回帖 登录 | 欢迎注册

本版积分规则

小黑屋|手机版|数学研发网 ( 苏ICP备07505100号 )

GMT+8, 2022-6-26 16:38 , Processed in 0.156599 second(s), 18 queries .

Powered by Discuz! X3.4

© 2001-2017 Comsenz Inc.

快速回复 返回顶部 返回列表