题意:给出几个圆的半径,贴着底下排放在一个长方形里面,求出如何摆放能使长方形底下长度最短。

由于球的个数不会超过8, 所以用全排列一个一个计算底下的长度,然后记录最短就行了。

全排列用next_permutation函数,计算长度时坐标模拟着摆放就行了。

摆放时折腾了不久,一开始一个一个把圆放到最左端,然后和前面摆好的圆比较检查是否会出现两个圆重叠,是的话就把当前圆向右移动到相切的位置。然后判断宽度。

结果发现过不了几个例子,检查了好久,终于发现问题出在初始位置上,如果出现一个特别小的圆放到最左端,然后和摆好的圆比较时就会跳过而没有移动,这样就会对后面的圆的摆放及判断产生影响。

于是把初始位置放在前一个圆的相切部分,然后再进行比较,想到可能出现这样摆放在有一个大圆出现时可能发生圆的左端超出左边的墙壁,于是多判断了一下。然后终于把uva论坛上的全部样例都过了。

可是接下来就出现了坑爹的事情了。交到uva上面老wa,结果搞了一早上却给wa掉实在令人沮丧。下午lzg同学告诉我这题的数据可能非常大,我可能是数字初始化时初始化得太小。果不其然,改成1e9就过了,在此感谢下lzg同学的帮助。

本来考虑全排列时有一个想法,如果圆全排列求解的话,一个摆放方法的解会和它倒过来的解释一样的,于是只需要判断前面一半的排列,从而减掉一半的计算量。可是当我这样去做时却wa掉了,我不知道到底这样会有什么问题,这题折腾了太久拖着我的进度,所以就先这样了。如果看官有什么想法的话可以留言评论下。

以下是我的代码:

  1. #include <cstdio>
  2. #include <cmath>
  3. #include <iostream>
  4. #include <algorithm>
  5. using namespace std;
  6.  
  7. double r[10], M, sum;
  8. int n, t; //tm放阶乘的一半
  9.  
  10. double cdis(double a, double b) { //circles' dis
  11. return 2 * sqrt(a * b);
  12. }
  13. double pdis(double x, double y) { //points' dis
  14. return sqrt(x * x + y * y);
  15. }
  16.  
  17. double check() {
  18. int i, j;
  19. double x[10], y[10], left = 0;
  20. for (i = 0; i < t; i++) {
  21. y[i] = r[i];
  22. if (i == 0)
  23. x[i] = r[i];
  24. else
  25. x[i] = x[i - 1] + cdis(r[i], r[i - 1]);
  26. if (x[i] < r[i])
  27. x[i] = r[i];
  28. for (j = 0; j < i; j++) {
  29. if (r[i] + r[j] > pdis(x[i] - x[j], y[i] - y[j])) {
  30. x[i] = x[j] + cdis(r[i], r[j]);
  31. }
  32. }
  33. if (left < x[i] + r[i])
  34. left = x[i] + r[i];
  35. }
  36. return left;
  37. }
  38.  
  39. int main() {
  40. scanf("%d", &n);
  41. while (n--) {
  42. M = 1000000000;
  43. scanf("%d", &t);
  44. for (int i = 0; i < t; i++)
  45. scanf("%lf", &r[i]);
  46. check();
  47. sort (r, r + t);
  48. do {
  49. sum = check();
  50. if (sum < M)
  51. M = sum;
  52. } while (next_permutation(r, r + t));
  53. printf("%.3lf\n", M);
  54. }
  55. return 0;
  56. }

这题给我的教训就是:

当一个数的类型为double时,它的值可能非常大,数据也可能非常大,这时候最大值要尽量开到最大。

下面是数据:

Input:

  1. 100
  2. 8 1.344 0.852 0.269 1.472 3.170 1.329 0.579 2.847
  3. 3 0.196 0.009 0.735
  4. 7 0.030 3.821 1.368 1.545 5.434 0.934 0.105
  5. 3 0.467 0.889 0.461
  6. 7 0.744 1.173 1.035 0.354 0.300 1.102 0.708
  7. 6 1.419 5.220 1.208 0.714 1.741 8.151
  8. 7 0.453 2.879 1.834 3.639 1.361 0.558 1.280
  9. 8 10.519 0.553 4.513 0.911 1.170 0.293 0.678 1.463
  10. 2 1.069 0.616
  11. 5 1.780 3.458 2.220 0.659 0.750
  12. 8 0.146 1.085 7.379 0.992 4.334 3.427 0.608 2.375
  13. 1 0.155
  14. 5 0.119 2.052 0.379 2.150 0.693
  15. 4 63.499 0.249 3.666 0.322
  16. 5 1.890 4.796 0.583 0.187 0.347
  17. 1 1.079
  18. 4 0.209 1.862 1.430 5.867
  19. 8 3.265 0.590 0.054 1.583 0.074 1.585 0.525 0.989
  20. 4 2.232 7.205 150.375 1.467
  21. 1 11.740
  22. 6 10.779 3.807 1.716 0.428 0.536 1.224
  23. 4 1.071 2.685 0.794 0.117
  24. 4 0.608 0.486 0.135 4.533
  25. 1 0.469
  26. 8 2.294 0.756 10.556 3.538 2.250 0.383 0.858 1.160
  27. 3 2.463 1.446 1.809
  28. 5 2.174 0.154 0.322 0.539 0.847
  29. 7 0.429 1.694 2.170 0.214 0.369 0.275 8.182
  30. 5 2.159 0.739 1.132 0.733 0.328
  31. 3 7.906 3.212 1.724
  32. 1 3.759
  33. 4 2.750 1.045 1.434 19.391
  34. 2 0.241 12.710
  35. 4 0.900 0.978 0.568 0.968
  36. 7 1.056 0.084 1.089 3.910 0.114 1.221 2.411
  37. 3 2.301 1.375 0.298
  38. 2 0.376 0.532
  39. 4 2.275 0.261 0.087 2.705
  40. 5 0.605 1.057 0.257 0.706 0.861
  41. 3 0.203 0.627 0.848
  42. 1 4.048
  43. 5 3.357 0.641 4.038 0.864 0.667
  44. 8 0.252 0.416 1.932 0.365 0.621 0.502 8.299 0.318
  45. 2 40.436 3.087
  46. 7 0.682 2.496 0.322 0.786 0.128 0.625 0.438
  47. 4 1.042 2.291 0.724 1.504
  48. 8 1.460 5.581 0.001 25.125 1.713 2.704 0.342 0.716
  49. 6 0.102 0.469 0.859 4.451 2.170 1.602
  50. 8 1.830 14.377 0.517 0.685 1.184 0.001 1.011 1.385
  51. 6 0.855 0.000 1.823 0.768 0.426 1.157
  52. 5 0.647 2.051 0.537 1.676 0.339
  53. 3 3.623 0.364 0.994
  54. 8 0.947 1.024 0.263 0.773 1.279 4.074 49.961 0.065
  55. 2 6.345 16.925
  56. 5 4.651 0.156 1.075 0.480 2.629
  57. 5 1.256 0.227 0.054 0.035 1.912
  58. 2 1.203 0.751
  59. 7 5.175 0.518 1.108 8.091 0.274 1.003 0.555
  60. 6 0.291 0.175 0.370 7.216 0.554 1.628
  61. 7 0.847 0.676 0.577 0.492 1.407 0.868 10.257
  62. 2 0.812 1.108
  63. 6 1.286 19.802 0.499 0.333 0.598 13.306
  64. 3 0.688 0.263 21.964
  65. 1 0.748
  66. 8 0.203 1.499 23.346 1.314 2.114 0.833 1.757 14.082
  67. 7 7.280 0.942 0.389 1.521 1.467 0.963 2.634
  68. 6 0.588 0.239 0.647 2.450 1.536 0.291
  69. 8 22.087 1.160 10.010 0.527 1.168 0.720 0.184 0.670
  70. 7 3.225 1.402 1.486 2.549 1.023 1.008 2.263
  71. 2 0.955 1.202
  72. 5 3.073 7.774 6.587 8.906 1.282
  73. 6 0.301 0.835 4.213 0.848 5.414 1.315
  74. 4 0.731 2.590 2.308 0.235
  75. 1 1.250
  76. 8 0.383 3.919 0.738 0.429 0.663 0.698 1.331 1.531
  77. 7 1.280 0.356 0.686 1.039 0.680 0.058 0.490
  78. 6 1.031 0.174 1.945 0.773 0.680 0.466
  79. 8 0.413 0.689 4.510 0.694 1.453 3.161 0.971 0.283
  80. 3 0.781 1.030 1.666
  81. 3 0.061 1.953 1.654
  82. 3 0.036 0.741 0.477
  83. 3 1.826 2.268 2.851
  84. 7 0.319 2.537 1.363 35.278 0.172 6.054 4.533
  85. 2 5.517 1.447
  86. 2 0.226 0.493
  87. 8 2.559 0.443 4.470 1.445 1.162 0.258 0.193 1.644
  88. 4 0.563 3.274 1.186 0.803
  89. 8 0.303 7.870 17.105 0.734 1.000 6.424 3.592 2.105
  90. 7 1.028 2.475 1.486 0.505 0.480 0.133 1.702
  91. 2 0.528 1.190
  92. 4 8.753 0.326 0.944 0.843
  93. 2 0.870 1.001
  94. 4 0.324 0.899 0.772 5.190
  95. 8 0.182 2.026 12.486 2.303 1.066 4.099 0.923 1.286
  96. 7 2.644 0.931 0.367 0.779 0.618 0.190 11.166
  97. 8 1.903 0.002 1.174 3.766 0.789 1.874 7.221 0.830
  98. 8 0.579 0.657 0.518 0.567 19.806 0.080 0.186 2.428
  99. 6 0.778 3.006 5.973 8.024 0.042 0.268
  100. 7 0.148 0.226 3.190 0.146 1.708 0.398 0.317
  101. 5 2.595 0.559 0.306 1.292 1.908

Output:

  1. 20.334
  2. 1.690
  3. 21.870
  4. 3.497
  5. 9.809
  6. 28.015
  7. 20.397
  8. 28.812
  9. 3.308
  10. 14.987
  11. 32.716
  12. 0.310
  13. 9.063
  14. 126.998
  15. 12.707
  16. 2.158
  17. 15.695
  18. 14.333
  19. 300.750
  20. 23.480
  21. 27.398
  22. 8.177
  23. 9.066
  24. 0.938
  25. 31.701
  26. 11.251
  27. 6.269
  28. 19.737
  29. 8.877
  30. 22.398
  31. 7.518
  32. 38.782
  33. 25.420
  34. 6.718
  35. 17.124
  36. 7.233
  37. 1.802
  38. 9.941
  39. 6.453
  40. 3.018
  41. 8.096
  42. 14.976
  43. 18.239
  44. 80.872
  45. 8.694
  46. 10.299
  47. 54.389
  48. 15.754
  49. 28.754
  50. 9.145
  51. 8.777
  52. 8.412
  53. 99.922
  54. 43.996
  55. 15.114
  56. 6.267
  57. 3.855
  58. 26.208
  59. 15.699
  60. 20.514
  61. 3.817
  62. 65.572
  63. 43.928
  64. 1.496
  65. 73.691
  66. 23.309
  67. 9.041
  68. 61.835
  69. 23.824
  70. 4.300
  71. 49.918
  72. 20.044
  73. 10.248
  74. 2.500
  75. 15.232
  76. 8.357
  77. 8.829
  78. 18.325
  79. 6.712
  80. 7.202
  81. 2.407
  82. 13.743
  83. 70.560
  84. 12.615
  85. 1.387
  86. 20.281
  87. 9.581
  88. 61.570
  89. 13.133
  90. 3.303
  91. 17.506
  92. 3.737
  93. 10.409
  94. 34.572
  95. 24.677
  96. 27.367
  97. 39.612
  98. 32.294
  99. 9.566
  100. 11.336

UVa 10012 - How Big Is It? 堆球问题 全排列+坐标模拟 数据的更多相关文章

  1. (转)在.NET程序运行过程中,什么是堆,什么是栈?什么情况下会在堆(栈)上分配数据?它们有性能上的区别吗?“结构”对象可能分配在堆上吗?什么情况下会发生,有什么需要注意的吗?

    转自:http://www.cnblogs.com/xiaoyao2011/archive/2011/09/09/2172427.html 在.NET程序运行过程中,什么是堆,什么是栈? 堆也就是托管 ...

  2. uva 10012

    题目意思:  给定m个圆的半径,现在要求找到一个矩形使得每一个球都以地面相切,要求输出最小的矩阵的长度 #include <iostream> #include <algorithm ...

  3. UVA 10012 How Big Is It?(暴力枚举)

      How Big Is It?  Ian's going to California, and he has to pack his things, including his collection ...

  4. 九度OJ 1068 球半径和数量 (模拟)

    题目1068:球的半径和体积 时间限制:1 秒 内存限制:32 兆 特殊判题:否 提交:4797 解决:1696 题目描写叙述: 输入球的中心点和球上某一点的坐标,计算球的半径和体积 输入: 球的中心 ...

  5. uva 327 Evaluating Simple C Expressions 简易C表达式计算 stl模拟

    由于没有括号,只有+,-,++,--,优先级简单,所以处理起来很简单. 题目要求计算表达式的值以及涉及到的变量的值. 我这题使用stl的string进行实现,随便进行练手,用string的erase删 ...

  6. uva 10344 23 out of 5 凑运算结果 全排列+dfs

    五个数三个运算符号,排列之后凑成结果为23,不考虑优先级. 很水,数据量也不大,先生成五个数的全排列,用dfs找出结果能否为23即可. 代码: #include <cstdio> #inc ...

  7. UVA - 11093 Just Finish it up(环形跑道)(模拟)

    题意:环形跑道上有n(n <= 100000)个加油站,编号为1~n.第i个加油站可以加油pi加仑.从加油站i开到下一站需要qi加仑汽油.你可以选择一个加油站作为起点,起始油箱为空(但可以立即加 ...

  8. ACM 找球号(一)

    找球号(一) 时间限制:3000 ms  |  内存限制:65535 KB 难度:3   描述 在某一国度里流行着一种游戏.游戏规则为:在一堆球中,每个球上都有一个整数编号i(0<=i<= ...

  9. nyoj 86 找球号(一)

    点击打开链接 找球号(一) 时间限制:3000 ms  |  内存限制:65535 KB 难度:3 描述 在某一国度里流行着一种游戏.游戏规则为:在一堆球中,每个球上都有一个整数编号i(0<=i ...

随机推荐

  1. Conversion to Dalvik format failed with error 1

    主要和添�的第三方的包有关系. ======================================= 出现,Conversion to Dalvik format failed with e ...

  2. POJ 2240 Arbitrage(最短路 套汇)

    题意  给你n种币种之间的汇率关系  推断是否能形成套汇现象  即某币种多次换为其他币种再换回来结果比原来多 基础的最短路  仅仅是加号换为了乘号 #include<cstdio> #in ...

  3. UVA - 12232 Exclusive-OR (并查集扩展偏离向量)

    Description You are not given n non-negative integersX0,X1,..., Xn-1 less than220, but they do exist ...

  4. jQuery Ajax: $.post请求示例

    jQuery Ajax: $.post请求示例 leyangjun.html页面 <html> <head> <meta http-equiv="Content ...

  5. 排序算法c语言描述---冒泡排序

    排序算法系列学习,主要描述冒泡排序,选择排序,直接插入排序,希尔排序,堆排序,归并排序,快速排序等排序进行分析. 文章规划: 一.通过自己对排序算法本身的理解,对每个方法写个小测试程序. 具体思路分析 ...

  6. MDCC 2014移动开发者大会 小礼品展商活动

    MDCC 2014移动开发者大会 小礼品展商活动 watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdGVzdGNzX2Ru/font/5a6L5L2T/fon ...

  7. SpringSecutiry权限管理手册

    SpringSecutiry权限管理手册: 请见以下URL: http://www.mossle.com/docs/auth/html/preface.html Spring Security 参考文 ...

  8. EXCEL随机密码生成函数

    =CHAR(INT(RAND()*+))&INT(RAND()*+)&CHAR(INT(RAND()*+))&INT(RAND()*+)&CHAR(INT(RAND() ...

  9. redirect的错误用法asp.net怎么使用自定义错误

    工作了几年,写过程序也运营过网站,自定义错误也很熟悉了,最近再做项目发现有同事写了这样的代码 if (action != null) { id = Request.QueryString[" ...

  10. android中获取屏幕的信息

    获取屏幕信息比较简单,可以通过android的sdk自带的工具类DisplayMetrics.话不多说,上代码: // 获取屏幕的信息 DisplayMetrics dm = new DisplayM ...