T1 神奇的幻方

题目描述

幻方是一种很神奇的N*N矩阵：它由数字1,2,3,……,N*N构成，且每行、每列及两条对角线上的数字之和都相同。

当N为奇数时，我们可以通过以下方法构建一个幻方：

首先将1写在第一行的中间。

之后，按如下方式从小到大依次填写每个数K(K=2,3,…,N*N)：

1.若(K−1)在第一行但不在最后一列，则将K填在最后一行，(K−1)所在列的右一列；

2.若(K−1)在最后一列但不在第一行，则将K填在第一列，(K−1)所在行的上一行；

3.若(K−1)在第一行最后一列，则将K填在(K−1)的正下方；

4.若(K−1)既不在第一行，也不在最后一列，如果(K−1)的右上方还未填数，则将K填在(K−1)的右上方，否则将K填在(K−1)的正下方。

现给定N请按上述方法构造N*N的幻方。

输入输出格式

输入格式：

输入文件只有一行，包含一个整数N即幻方的大小。

输出格式：

输出文件包含N行，每行N个整数，即按上述方法构造出的N*N的幻方。相邻两个整数之间用单个空格隔开。

输入输出样例

输入样例#1：

  1. 3
输出样例#1：

  1. 8 1 6
  2. 3 5 7
  3. 4 9 2
输入样例#2：

  1. 25
输出样例#2：

  1. 327 354 381 408 435 462 489 516 543 570 597 624 1 28 55 82 109 136 163 190 217 244 271 298 325
  2. 353 380 407 434 461 488 515 542 569 596 623 25 27 54 81 108 135 162 189 216 243 270 297 324 326
  3. 379 406 433 460 487 514 541 568 595 622 24 26 53 80 107 134 161 188 215 242 269 296 323 350 352
  4. 405 432 459 486 513 540 567 594 621 23 50 52 79 106 133 160 187 214 241 268 295 322 349 351 378
  5. 431 458 485 512 539 566 593 620 22 49 51 78 105 132 159 186 213 240 267 294 321 348 375 377 404
  6. 457 484 511 538 565 592 619 21 48 75 77 104 131 158 185 212 239 266 293 320 347 374 376 403 430
  7. 483 510 537 564 591 618 20 47 74 76 103 130 157 184 211 238 265 292 319 346 373 400 402 429 456
  8. 509 536 563 590 617 19 46 73 100 102 129 156 183 210 237 264 291 318 345 372 399 401 428 455 482
  9. 535 562 589 616 18 45 72 99 101 128 155 182 209 236 263 290 317 344 371 398 425 427 454 481 508
  10. 561 588 615 17 44 71 98 125 127 154 181 208 235 262 289 316 343 370 397 424 426 453 480 507 534
  11. 587 614 16 43 70 97 124 126 153 180 207 234 261 288 315 342 369 396 423 450 452 479 506 533 560
  12. 613 15 42 69 96 123 150 152 179 206 233 260 287 314 341 368 395 422 449 451 478 505 532 559 586
  13. 14 41 68 95 122 149 151 178 205 232 259 286 313 340 367 394 421 448 475 477 504 531 558 585 612
  14. 40 67 94 121 148 175 177 204 231 258 285 312 339 366 393 420 447 474 476 503 530 557 584 611 13
  15. 66 93 120 147 174 176 203 230 257 284 311 338 365 392 419 446 473 500 502 529 556 583 610 12 39
  16. 92 119 146 173 200 202 229 256 283 310 337 364 391 418 445 472 499 501 528 555 582 609 11 38 65
  17. 118 145 172 199 201 228 255 282 309 336 363 390 417 444 471 498 525 527 554 581 608 10 37 64 91
  18. 144 171 198 225 227 254 281 308 335 362 389 416 443 470 497 524 526 553 580 607 9 36 63 90 117
  19. 170 197 224 226 253 280 307 334 361 388 415 442 469 496 523 550 552 579 606 8 35 62 89 116 143
  20. 196 223 250 252 279 306 333 360 387 414 441 468 495 522 549 551 578 605 7 34 61 88 115 142 169
  21. 222 249 251 278 305 332 359 386 413 440 467 494 521 548 575 577 604 6 33 60 87 114 141 168 195
  22. 248 275 277 304 331 358 385 412 439 466 493 520 547 574 576 603 5 32 59 86 113 140 167 194 221
  23. 274 276 303 330 357 384 411 438 465 492 519 546 573 600 602 4 31 58 85 112 139 166 193 220 247
  24. 300 302 329 356 383 410 437 464 491 518 545 572 599 601 3 30 57 84 111 138 165 192 219 246 273
  25. 301 328 355 382 409 436 463 490 517 544 571 598 625 2 29 56 83 110 137 164 191 218 245 272 299

说明

对于100%的数据，1<=N<=39且N为奇数。

NOIp2015 提高组 d1t1

  1. #include<cstdio>
  2. #include<cstdlib>
  3. #include<cstring>
  4. #include<iostream>
  5. #include<algorithm>
  6. #define N 100
  7. using namespace std;
  8. int n,b[N][N];
  9. bool vis[N][N];
  10. struct A
  11. {
  12.     int x,y;
  13. }a[N];
  14. int read()
  15. {
  16.     ,f=;char ch=getchar();
  17.     ; ch=getchar();}
  18.     +ch-'; ch=getchar();}
  19.     return x*f;
  20. }
  21. int main()
  22. {
  23.     n=read();
  24.     a[].x=;a[].y=n/+;vis[a[].x][a[].y]=].x][a[].y]=;
  25.     ;i<=n*n;i++)
  26.     {
  27.         ].x==&&a[i-].y!=n) {a[i].x=n,a[i].y=a[i-].y+;          b[a[i].x][a[i].y]=i; vis[a[i].x][a[i].y]=true; continue;}
  28.         ].x!=&&a[i-].y==n) {a[i].y=,a[i].x=a[i-].x-;          b[a[i].x][a[i].y]=i; vis[a[i].x][a[i].y]=true; continue;}
  29.         ].x==&&a[i-].y==n) {a[i].x=a[i-].x+,a[i].y=a[i-].y; b[a[i].x][a[i].y]=i; vis[a[i].x][a[i].y]=true; continue;}
  30.         ].x!=&&a[i-].y!=n)
  31.         {
  32.             ].x-][a[i-].y+]&&a[i-].x->=&&a[i-].x-<=n&&a[i-].y+>&&a[i-].y+<=n)
  33.               {a[i].x=a[i-].x-,a[i].y=a[i-].y+; b[a[i].x][a[i].y]=i; vis[a[i].x][a[i].y]=true;}
  34.             ].x+,a[i].y=a[i-].y; b[a[i].x][a[i].y]=i; vis[a[i].x][a[i].y]=true;}
  35.             continue;
  36.         }
  37.     }
  38.     ;i<=n;i++)
  39.     {
  40.         ;j<=n;j++)
  41.          printf("%d ",b[i][j]);
  42.           printf("\n");
  43.      }
  44.     ;
  45. }

莫名RE 70

mdzz忘记自己还开了个结构体这个事情了、、、

Ｏ(≧口≦)Ｏ    zz 啊！！！ 结构体下标为这个数，而数最大要到40*40，因此会RE

  1. #include<cstdio>
  2. #include<cstdlib>
  3. #include<cstring>
  4. #include<iostream>
  5. #include<algorithm>
  6. #define N 1600
  7. using namespace std;
  8. int n,b[N][N];
  9. bool vis[N][N];
  10. struct A
  11. {
  12.     int x,y;
  13. }a[N];
  14. int read()
  15. {
  16.     ,f=;char ch=getchar();
  17.     ; ch=getchar();}
  18.     +ch-'; ch=getchar();}
  19.     return x*f;
  20. }
  21. int main()
  22. {
  23.     n=read();
  24.     a[].x=;a[].y=n/+;vis[a[].x][a[].y]=].x][a[].y]=;
  25.     ;i<=n*n;i++)
  26.     {
  27.         ].x==&&a[i-].y!=n) {a[i].x=n,a[i].y=a[i-].y+;          b[a[i].x][a[i].y]=i; vis[a[i].x][a[i].y]=true; continue;}
  28.         ].x!=&&a[i-].y==n) {a[i].y=,a[i].x=a[i-].x-;          b[a[i].x][a[i].y]=i; vis[a[i].x][a[i].y]=true; continue;}
  29.         ].x==&&a[i-].y==n) {a[i].x=a[i-].x+,a[i].y=a[i-].y; b[a[i].x][a[i].y]=i; vis[a[i].x][a[i].y]=true; continue;}
  30.         ].x!=&&a[i-].y!=n)
  31.         {
  32.             ].x-][a[i-].y+]&&a[i-].x->=&&a[i-].x-<=n&&a[i-].y+>&&a[i-].y+<=n)
  33.               {a[i].x=a[i-].x-,a[i].y=a[i-].y+; b[a[i].x][a[i].y]=i; vis[a[i].x][a[i].y]=true;}
  34.             ].x+,a[i].y=a[i-].y; b[a[i].x][a[i].y]=i; vis[a[i].x][a[i].y]=true;}
  35.             continue;
  36.         }
  37.     }
  38.     ;i<=n;i++)
  39.     {
  40.         ;j<=n;j++)
  41.          printf("%d ",b[i][j]);
  42.           printf("\n");
  43.      }
  44.     ;
  45. }

AC代码

　　　　　　　　　　　　　　　　T2   信息传递

题目描述

有n个同学（编号为1到n）正在玩一个信息传递的游戏。在游戏里每人都有一个固定的信息传递对象，其中，编号为i的同学的信息传递对象是编号为Ti同学。

游戏开始时，每人都只知道自己的生日。之后每一轮中，所有人会同时将自己当前所知的生日信息告诉各自的信息传递对象（注意：可能有人可以从若干人那里获取信息，但是每人只会把信息告诉一个人，即自己的信息传递对象）。当有人从别人口中得知自己的生日时，游戏结束。请问该游戏一共可以进行几轮？

输入输出格式

输入格式：

输入共2行。

第1行包含1个正整数n表示n个人。

第2行包含n个用空格隔开的正整数T1,T2,……,Tn其中第i个整数Ti示编号为i

的同学的信息传递对象是编号为Ti的同学，Ti≤n且Ti≠i

数据保证游戏一定会结束。

输出格式：

输出共 1 行，包含 1 个整数，表示游戏一共可以进行多少轮。

输入输出样例

输入样例#1：

  1. 5
  2. 2 4 2 3 1
输出样例#1：

  1. 3

说明

样例1解释

游戏的流程如图所示。当进行完第 3 轮游戏后， 4 号玩家会听到 2 号玩家告诉他自

己的生日，所以答案为 3。当然，第 3 轮游戏后， 2 号玩家、 3 号玩家都能从自己的消息

来源得知自己的生日，同样符合游戏结束的条件。

对于 30%的数据， n ≤ 200；

对于 60%的数据， n ≤ 2500；

对于 100%的数据， n ≤ 200000。

tarjan求最小的环

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<cstdlib>
  4. #include<iostream>
  5. #include<algorithm>
  6. #define N 210000
  7. using namespace std;
  8. bool vis[N];
  9. int n,m,tim,top,tot,sum;
  10. int dfn[N],low[N],ans[N],head[N],stack[N],belong[N];
  11. int read()
  12. {
  13.     ,f=; char ch=getchar();
  14.     ; ch=getchar();}
  15.     +ch-'; ch=getchar();}
  16.     return x*f;
  17. }
  18. struct Edge
  19. {
  20.     int to,from,next;
  21. }edge[N];
  22. int add(int x,int y)
  23. {
  24.     tot++;
  25.     edge[tot].to=y;
  26.     edge[tot].next=head[x];
  27.     head[x]=tot;
  28. }
  29. int tarjan(int now)
  30. {
  31.     dfn[now]=low[now]=++tim;
  32.     stack[++top]=now; vis[now]=true;
  33.     for(int i=head[now];i;i=edge[i].next)
  34.     {
  35.         int t=edge[i].to;
  36.         if(vis[t]) low[now]=min(low[now],dfn[t]);
  37.         else if(!dfn[t]) tarjan(t),low[now]=min(low[now],low[t]);
  38.     }
  39.     if(low[now]==dfn[now])
  40.     {
  41.         sum++;belong[now]=sum;ans[sum]++;
  42.         for(;stack[top]!=now;top--)
  43.          belong[stack[top]]=sum,vis[stack[top]]=false,ans[sum]++;
  44.         vis[now]=false; top--;
  45.     }
  46. }
  47. int main()
  48. {
  49.     n=read();
  50.     ;i<=n;i++)
  51.      m=read(),add(i,m);
  52.     ;i<=n;i++)
  53.      if(!dfn[i]) tarjan(i);
  54.     sort(ans+,ans++sum);
  55.     ;i<=sum;i++)
  56.      )
  57.      {
  58.        printf("%d",ans[i]);
  59.        ;
  60.      }
  61. }

tarjan AC代码

　　　　　　　　　　　　　　T3    斗地主

题目描述

牛牛最近迷上了一种叫斗地主的扑克游戏。斗地主是一种使用黑桃、红心、梅花、方片的A到K加上大小王的共54张牌来进行的扑克牌游戏。在斗地主中，牌的大小关系根据牌的数码表示如下：3<4<5<6<7<8<9<10<J<Q<K<A<2<小王<大王，而花色并不对牌的大小产生影响。每一局游戏中，一副手牌由n张牌组成。游戏者每次可以根据规定的牌型进行出牌，首先打光自己的手牌一方取得游戏的胜利。

现在，牛牛只想知道，对于自己的若干组手牌，分别最少需要多少次出牌可以将它们打光。请你帮他解决这个问题。

需要注意的是，本题中游戏者每次可以出手的牌型与一般的斗地主相似而略有不同。

具体规则如下：

本题数据随机，不支持hack，要hack或强力数据请点击这里

注意这里4可以带两对

输入输出格式

输入格式：

第一行包含用空格隔开的2个正整数T和n，表示手牌的组数以及每组手牌的张数。

接下来T组数据，每组数据n行，每行一个非负整数对aibi表示一张牌，其中ai示牌的数码，bi表示牌的花色，中间用空格隔开。特别的，我们用1来表示数码A，11表示数码J，12表示数码Q，13表示数码K；黑桃、红心、梅花、方片分别用1-4来表示；小王的表示方法为01，大王的表示方法为02。

输出格式：

共T行，每行一个整数，表示打光第i手牌的最少次数。

输入输出样例

输入样例#1：

  1. 1 8
  2. 7 4
  3. 8 4
  4. 9 1
  5. 10 4
  6. 11 1
  7. 5 1
  8. 1 4
  9. 1 1
输出样例#1：

  1. 3
输入样例#2：

  1. 1 17
  2. 12 3
  3. 4 3
  4. 2 3
  5. 5 4
  6. 10 2
  7. 3 3
  8. 12 2
  9. 0 1
  10. 1 3
  11. 10 1
  12. 6 2
  13. 12 1
  14. 11 3
  15. 5 2
  16. 12 4
  17. 2 2
  18. 7 2
输出样例#2：

  1. 6

说明

样例1说明

共有1组手牌，包含8张牌：方片7，方片8，黑桃9，方片10，黑桃J，黑桃5，方片A以及黑桃A。可以通过打单顺子（方片7，方片8，黑桃9，方片10，黑桃J），单张牌（黑桃5）以及对子牌（黑桃A以及方片A）在3次内打光。

对于不同的测试点， 我们约定手牌组数T与张数n的规模如下：

数据保证：所有的手牌都是随机生成的。

  1. zz啊、、开始的时候竟然读错题了！！！
  2. 以后绝对不能犯这种错误！！！
  3. #include<cstdio>
  4. #include<cstring>
  5. #include<cstdlib>
  6. #include<iostream>
  7. #include<algorithm>
  8. #define N 1600
  9. using namespace std;
  10. bool flag;
  11. int t,n,m,x,y,a[N],ans;
  12. int read()
  13. {
  14.     ,f=; char ch=getchar();
  15.     ; ch=getchar();}
  16.     +ch-'; ch=getchar();}
  17.     return x*f;
  18. }
  19. int main()
  20. {
  21.     t=read();n=read();
  22.     while(t--)
  23.     {
  24.         ans=;flag=false;
  25.         memset(a,,sizeof(a));
  26.         ;i<=n;i++)
  27.         {
  28.             x=read();y=read();
  29.             a[x]++;
  30.         }
  31.         ;i<=;i++)
  32.           ) {flag=;break;}
  33.         if(!flag)
  34.          ;i<=;i++) if(a[i]) ans++;
  35.         printf("%d\n",ans);
  36.     }
  37.     ;
  38. }

30分的部分分

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<cstdlib>
  4. #include<iostream>
  5. #include<algorithm>
  6. #define N 25
  7. using namespace std;
  8. int t,n,m,x,y,sum[N],card_num[N],ans,dp[N][N][N][N];
  9. ]={,,,};//存储我们要组成当前顺子，最少需要的牌数
  10. int read()
  11. {
  12.     ,f=; char ch=getchar();
  13.     ; ch=getchar();}
  14.     +ch-'; ch=getchar();}
  15.     return x*f;
  16. }
  17. int work(int s1,int s2,int s3,int s4,int king)
  18. {
  19.     )
  20.      s1++,king=;//如果只有一张王的话，我们只能将这张王看成1张单牌来处理
  21.     ) return dp[s4][s3][s2][s1];//
  22.     ],dp[s4][s3][s2][s1]+);//
  23. }
  24. void dfs(int now)//now 为到当前状态我们所出了几次牌
  25. {
  26.     memset(sum,,sizeof(sum));
  27.     if(now>ans) return ;//如果当前的出牌次数大于ans，return。我们要求最小的出牌次数
  28.     ;i<=;i++) sum[card_num[i]]++;//求出一共有几张单牌，几对双牌，、、、
  29.     ans=min(ans,now+work(sum[],sum[],sum[],sum[],card_num[]));//ans=当前已经出了的牌的次数+剩下的牌最少的出牌次数
  30.     ;k<=;k++) //找顺子，顺子一共有3种情况：单顺子，双顺子，三顺子
  31.     {
  32.         ;i<=;i++)
  33.         {
  34.             int j;
  35.             &&card_num[j]>=k;j++)//从当前牌开始到j 为顺子，如果顺子的排数小于k即不连续，continue
  36.              {
  37.                  card_num[j]-=k;
  38.                 >=sun_num[k])  dfs(now+);//可以组成顺子，出牌方案数+1；继续搜索
  39.              }
  40.             for(j--;j>=i;j--) card_num[j]+=k;//复原
  41.         }
  42.     }
  43. }
  44. int main()
  45. {
  46.     t=read();n=read();
  47.     /***********预处理处用dp[i][j][k][l]表示打出i套四张,j套三张,k套对拍,l张单拍要最少出几次。*********/
  48.     memset(dp,,sizeof(dp));
  49.     dp[][][][]=;
  50.     ;i<=n;i++)
  51.      ;j<=n;j++)
  52.       ;k<=n;k++)
  53.        ;l<=n;l++)
  54.         +j*+k*+l*<=n)
  55.         {
  56.              if(i)//有四张的牌
  57.              {
  58.                   ) dp[i][j][k][l]=min(dp[i][j][k][l],dp[i-][j][k-][l]+);//4带两对不一样的对牌
  59.                   ) dp[i][j][k][l]=min(dp[i][j][k][l],dp[i-][j][k][l-]+);//4带单张牌（四带二）
  60.                   dp[i][j][k][l]=min(dp[i][j][k][l],dp[i-][j][k][l]+);//炸弹，不带任何牌
  61.           }
  62.           if(j)//处理处有三张相同的牌时可以出的最少次数
  63.           {
  64.                ][k-][l]+);//三带一对
  65.                ][k][l-]+);//三带一
  66.                dp[i][j][k][l]=min(dp[i][j][k][l],dp[i][j-][k][l]+);//三张牌，什么也不带
  67.           }
  68.           if(k)//两张牌
  69.             dp[i][j][k][l]=min(dp[i][j][k][l],dp[i][j][k-][l]+);//对子
  70.           if(l)//单张牌
  71.             dp[i][j][k][l]=min(dp[i][j][k][l],dp[i][j][k][l-]+);//单张牌
  72.         }
  73.     /*************************************预处理部分************************************************/
  74.     while(t--)
  75.     {
  76.         memset(card_num,,sizeof(card_num));
  77.         ans=n;
  78.         ;i<=n;i++)
  79.         {
  80.             x=read(),y=read();
  81.             ) card_num[]++;//这个地方的存储使我们后面找顺子的时候比较方便，因为顺子最大到A
  82.             else card_num[x]++;
  83.         }
  84.         dfs();
  85.         printf("%d\n",ans);
  86.     }
  87.     ;
  88. }

dp预处理+dfs

小感：唉，zz！明明可以拿230的但是只拿了170~~~~(>_<)~~~~   第一题忘记开了个结构体，数组开小了，丢了30分，第三题n的输入写在了while的里面，然后TLE了！！

这告诉我们noip的时候一定要仔细读题！数组的大小再开的时候一定要慎重，看好数据范围以及数组内存的是什么东西，然后在写数组的大小！！

一定要读清题目，好好读题，明白题目中的每个变量代表的什么，什么表示什么、多读几遍题目！看清怎么输入！

noip 2015 day1的更多相关文章

  1. 洛谷P2668 斗地主==codevs 4610 斗地主[NOIP 2015 day1 T3]

    P2668 斗地主 326通过 2.6K提交 题目提供者洛谷OnlineJudge 标签搜索/枚举NOIp提高组2015 难度提高+/省选- 提交该题 讨论 题解 记录 最新讨论 出现未知错误是说梗啊 ...

  2. 4632 NOIP[2015] 运输计划

    4632 NOIP[2015] 运输计划  时间限制: 1 s  空间限制: 256000 KB  题目等级 : 大师 Master 题解       题目描述 Description 公元 2044 ...

  3. [NOIP 2015]运输计划-[树上差分+二分答案]-解题报告

    [NOIP 2015]运输计划 题面: A[NOIP2015 Day2]运输计划 时间限制 : 20000 MS 空间限制 : 262144 KB 问题描述 公元 2044 年,人类进入了宇宙纪元. ...

  4. Luogu 2680 NOIP 2015 运输计划（树链剖分，LCA，树状数组，树的重心，二分，差分）

    Luogu 2680 NOIP 2015 运输计划(树链剖分,LCA,树状数组,树的重心,二分,差分) Description L 国有 n 个星球,还有 n-1 条双向航道,每条航道建立在两个星球之 ...

  5. Luogu 2668 NOIP 2015 斗地主（搜索，动态规划）

    Luogu 2668 NOIP 2015 斗地主(搜索,动态规划) Description 牛牛最近迷上了一种叫斗地主的扑克游戏.斗地主是一种使用黑桃.红心.梅花.方片的A到K加上大小王的共54张牌来 ...

  6. [普及]NOIP 2015 推销员 贪心

    NOIP 2015 推销员 题意: 有一个喜欢疲劳的推销员,告诉你在一个单口胡同(数轴)中的n户家庭的位置,和向他们推销可以获得的疲劳度.分别输出向(1,2,3,4...n)户人家推销可以得到的最大疲 ...

  7. cogs 2109. [NOIP 2015] 运输计划 提高组Day2T3 树链剖分求LCA 二分答案 差分

    2109. [NOIP 2015] 运输计划 ★★★☆   输入文件:transport.in   输出文件:transport.out   简单对比时间限制:3 s   内存限制:256 MB [题 ...

  8. NOIP 2015普及组复赛Day1 T1 == Codevs4510 神奇的幻方

    时间限制: 1 s  空间限制: 128000 KB  题目等级 : 黄金 Gold  题目描述 Description: 幻方是一种很神奇的N∗N矩阵:它由数字 1,2,3, … … ,N∗N构成, ...

  9. NOIP 2015 提高组 Day1

    期望得分:100+100+100=300 实际得分:100+100+45=245 T3 相似的代码 复制过去 没有改全,痛失55分 http://www.cogs.pro/cogs/page/page ...

随机推荐

  1. linux下自定义pid实现任意数据采集

    当你需要采集特殊的数据,而不满足于现有的你所知的数据模版时,自定义oid将是你必须而且非常好的解决方式. oid是snmp服务器为每条系统信息提供的唯一标识符,如果不能很好理解snmp服务的话,可以将 ...

  2. Javaweb学习笔记8—DBUtils工具包

    今天来讲javaweb的第8阶段学习. DBUtils技术,DBUtils是我们操作数据库很常用的功能,虽然后期使用都是它的封装结果,但是也需要掌握. 老规矩,首先先用一张思维导图来展现今天的博客内容 ...

  3. TFS强制删除离职人员签出锁定项的方法（转）

      项目组一哥们走的时候以独占方式迁出了文件,现在其他人都无法修改,管理员似乎也无法将文件解除.经过摸索,找到了一种暴力的方法——直接改TFS数据库.虽然暴力,却能实实在在地解决这个问题. 步骤: 1 ...

  4. Tomcat7的安装与配置

    Tomcat的安装及配置我曾经使用过tomcat,并实现了一个简单的servlet程序.没想到再次安装tomcat的时候用浪费了我大半天的时间.我想有必要做个总结,否则下次不知又要花费我多少时间. 1 ...

  5. $.noconflict() 有什么用处

    jQuery默认使用"$"操作符,prototype等其他框架也是是使用"$",于是,如果jQuery在其他库之后引入,那么jQuery将获得"$&q ...

  6. tree iview treeData json数据 添加 selected 数据 要进行vue.set 进行响应式添加

    tree iview treeData json数据 添加 selected 数据 要进行vue.set 进行响应式添加

  7. 中位数II

    该题目与思路分析来自九章算法的文章,仅仅是自己做个笔记! 题目:数字是不断进入数组的,在每次添加一个新的数进入数组的同时返回当前新数组的中位数. 解答: 这道题是用堆解决的问题.用两个堆,max he ...

  8. Cycloid Hydraulic Motor Use: Use Failure And Treatment

    The cycloidal hydraulic motor is a small low-speed, high-torque hydraulic motor with a shaft-distrib ...

  9. AF_NETLINK

    读procd时,hotplug相关. 从网上资料来看,大概和硬件输入有关? 资料:http://www.cnblogs.com/sammei/p/4119659.html

  10. 条款23：宁一 non-member no-friend 替换member函数（prefer non-member non-friend functions to members functions）

    NOTE : 1.宁可拿non-member non-friend 函数替换member函数.这样做可以增加封装性/包裹单性(packaging flexibility)和机能扩展性.