精华内容
下载资源
问答
  • 前言每天都会遇到很多问题,大多数问题重复的,所以整理到公众号里,希望你们看一下,别再一遍遍问了......一般默认的万分之4,更早的甚至是千分之三!免五就是针对高频交易或者小资金交易,单笔手续费不满5元通...

    前言

    每天都会遇到很多问题,大多数问题是重复的,所以整理到公众号里,希望你们看一下,别再一遍遍问了....

    万一免五开户是真的吗?

    随着监管越来越严,可以给万一免五的券商也越来越少,只要赶在万一免五政策取消之前开户,就能永久享受万一免五的费率。

    万一就是万分之一的交易费用,交易一万块钱手续费1元。一般默认的是万分之4,更早的甚至是千分之三!

    免五就是针对高频交易或者小资金交易,单笔手续费不满5元通通都是按照5元收,相当于起步费。几乎所有券商默认的都是不免5的!

    开户加微信:

    5b8e418a2c8ab7e2fa1c628fe03e982d.png

    be2a0df4061b8815fec6d08ba2f080b8.png

    A

    券商的佣金都是双向收费的6c582b082635dc67fc034a9c3b1eb1a2.png

    fd02c71e172837502ef861cf71922d7d.png

    昨天有两个人问我,关于券商佣金单向收费与双向收费的问题。

    第一个人吻我的时候,我还斩钉截铁告诉他,券商佣金都是双向收费的,没有单向收费,结果同一天又有人问我同样的问题,搞得我都懵逼了,还自己百度了一下:

    f378b44a79bbcd4e01f8ccbf00ac3360.png

    券商佣金没有单向收费的,都是双向收费。

    B费率还有更便宜的吗?

    fdd14c76801a2282971b0ccff8ff067f.png

    6f0b00ee871e8980b9e805fbd9326386.png

    除了银河资金量500万以上两融利率可以给到5.5%,其他券商资金量大也没有什么可谈的余地,万一免五已经接近券商的成本价,万一免五全年贡献交易佣金可能只有几块钱,十几块钱,也没有余地再低了,再低就赔了。

    C-哪家券商最划算?

    b2968bfe87be377ec39caf620c72c3ad.png

    这取决于你的资金量和主要做什么。

    每一家我合作的券商,都有他的特别之处,找我合作的券商不止8家,之所以合作这八家,就是因为每家都各有所长。

    资金量大的不需要免五,川财最划算。川财的逆回购还没有任何手续费。

    所以,你上来就问我哪家券商好,哪家最划算,我也不知道你资金量多少,主要做什么,什么需求?

    A

    最近经常被问到的问题-有没有大券商?

    fcc27a30747cc666c00acd69259a0e00.png

    最近几天不止一个人跟我说,有没有合作大一点的券商?

    我也是一脸问号,我一共合作了八家券商,其中有五家是TOP10的券商,TOP3的券商合作了两家,哪儿还有更大的券商?

    其实,在大家的认识里,自己听说过的券商,哪怕再小,也是大券商,没听说过的券商,哪怕再大,也是小券商。

    比如,在我们小城市洛阳,用东海证券的非常多,因为东海在小城市的营业部比较大,所以小城市的人就会以为东海证券是大券商,其实是排不上名次的小券商。

    7129a7be1d91d093b76b59728c34797e.png

    B

    营业部在哪里?

    5ae635757dded9007110eace6c4a6db3.png

    我合作的营业部就是你所在的城市几率很小。

    但是,从你角度,在任何城市的营业部开户,都不影响你在当地的营业部办任何业务。

    昨天,有人跟我说,会营销销户。

    科普一下,柜台办理开户的,需要到柜台销户,线上开户的,都可以线上销户,跟我开户的都属于线上开户,可以直接线上销户,不需要去营业部。

    其实,大多数业务都是支持线上办理的,偶尔一些需要去柜台办理的业务,比如开通两融,你也不用跑到开户营业部办理,到全国任意一家营业部都可以办理。

    C-交割单是什么

    万一免五都是先预扣,晚上清算后才会出交割单!!!,无论是买入还是卖出,每一笔交易都有交割单。交割单里详细的展示了你这笔交易所有收取的费用。比如,我在公众号里发的:d0f4ef6b6e56e668519a846364eacbc1.png这是我的交割单。当然,我用的是海通,很多人跟我开户的是银河,银河如何查看交割单呢?银河证券在:交易 -  其他交易 - 交割单,里查看交割单。

    b1dc8dcaa601d59db7d77373ea450f5c.png

    还有人是在PC里查看交割单的,PC上交割单是不准确的,以银河APP里的交割单为准。

    展开全文
  • 1 *************************************************** ... 10 本金10000元存入银行,年利率是千分之三,每过1年,将本金和利息相加作为新的本金。计算5年后,获得的本金是多少? 11 12 13 14
      1 ***************************************************
      2 <!DOCTYPE html>
      3 <html lang="en">
      4 <head>
      5     <meta charset="UTF-8">
      6     <title>Document</title>
      7     
      8 </head>
      9 <body>
     10     本金10000元存入银行,年利率是千分之三,每过1年,将本金和利息相加作为新的本金。计算5年后,获得的本金是多少?
     11 </body>
     12 </html>
     13 <script>
     14     var money=10000;
     15     var rote=0.003;
     16     for(i=1;i<=5;i++){
     17         // money=money+money*rote;
     18         
     19         money*=1+rote;
     20     }
     21     alert(money);    
     22 </script>
     23 
     24 ***********************************************************
     25 <!DOCTYPE html>
     26 <html lang="en">
     27 <head>
     28     <meta charset="UTF-8">
     29     <title>Document</title>
     30 </head>
     31 <body>
     32     有个人想知道,一年之内一对兔子能繁殖多少对?于是就筑了一道围墙把一对兔子关在里面。已知一对兔子每个月可以生一对小兔子,而一对兔子从出生后第3个月起每月生一对小兔子。假如一年内没有发生死亡现象,那么,一对兔子一年内(12个月)能繁殖成多少对?
     33 兔子的规律为数列,1,1,2,      3,      5,           8,   13,     21
     34                  n1 n2 n3=n1+n2,n4=n2+n3,n5=n4+n3......
     35 斐波那契数列:1,1,2,3,5,8,13,21,34,55,89,144...........
     36 </body>
     37 </html>
     38 <script>
     39     var n1=1;
     40     var n2=1;
     41     var temp=0;
     42     for(var i=3;i<=12;i++){
     43     temp=n2;//temp=n2=1    temp=n2=2          temp=n2=3          temp=n2=5
     44     n2=n1+n2;//2(n2)=1+1   3(n2)=n1(1)+n2(2)  5(n2)=n1(2)+n2(3)  8(n2)=n1(3)+n2(5)
     45     n1=temp;//n1=1         n1=2               n1=3               n1=5
     46     }
     47     alert(n2);
     48 </script>
     49 144
     50 *************************************
     51 <!DOCTYPE html>
     52 <html lang="en">
     53 <head>
     54     <meta charset="UTF-8">
     55     <title>Document</title>
     56 </head>
     57 <body>
     58     
     59     //需求:打印宽9,长9的正方形<br>
     60 </body>
     61 </html>
     62 <script>
     63     for(var j=1;j<=9;j++){
     64         for(var i=1;i<=9;i++){
     65             document.write("★");
     66         }
     67         document.write("<br>");
     68     }
     69 </script>
     70 ★★★★★★★★★
     71 ★★★★★★★★★
     72 ★★★★★★★★★
     73 ★★★★★★★★★
     74 ★★★★★★★★★
     75 ★★★★★★★★★
     76 ★★★★★★★★★
     77 ★★★★★★★★★
     78 ★★★★★★★★★
     79 *****************************************
     80 <!DOCTYPE html>
     81 <html lang="en">
     82 <head>
     83     <meta charset="UTF-8">
     84     <title>Document</title>
     85 </head>
     86 <body>
     87     
     88     //需求:打印宽9,长9的正方形<br>
     89     //需求:打印宽9,长9的直角三角形<br>
     90 </body>
     91 </html>
     92 <script>
     93     for(var j=1;j<=9;j++){
     94         for(var i=1;i<=9;i++){
     95             document.write("★");
     96         }
     97         document.write("<br>");
     98     }
     99     document.write("<br>");
    100     for(var j=1;j<=9;j++){
    101         for(var i=1;i<=j;i++){
    102             document.write("☆");
    103         }
    104         document.write("<br>");
    105     }
    106 </script>
    107 **********************************************
    108 <!DOCTYPE html>
    109 <html lang="en">
    110 <head>
    111     <meta charset="UTF-8">
    112     <title>Document</title>
    113 </head>
    114 <body>
    115     
    116     //需求:打印宽9,长9的正方形<br>
    117     //需求:打印宽9,长9的直角三角形<br>
    118     //需求:表格输出99乘法表<br>
    119 </body>
    120 </html>
    121 <script>
    122     for(var j=1;j<=9;j++){
    123         for(var i=1;i<=9;i++){
    124             document.write("★");
    125         }
    126         document.write("<br>");
    127     }
    128     document.write("<br>");
    129     for(var j=1;j<=9;j++){
    130         for(var i=1;i<=j;i++){
    131             document.write("☆");
    132         }
    133         document.write("<br>");
    134     }
    135 
    136 
    137     document.write("<br>");
    138 
    139     document.write("<table border='1'>");
    140     
    141     for(var j=1;j<=9;j++){
    142         document.write("<tr>");
    143         for(var i=1;i<=j;i++){
    144             
    145             document.write("<td>");
    146             document.write(i+"X"+j+"="+i*j);
    147             document.write("</td>");
    148             
    149         }
    150         document.write("</tr>");
    151         
    152     }
    153 
    154 
    155     document.write("</table>");
    156 </script>
    157 158 ☆☆
    159 ☆☆☆
    160 ☆☆☆☆
    161 ☆☆☆☆☆
    162 ☆☆☆☆☆☆
    163 ☆☆☆☆☆☆☆
    164 ☆☆☆☆☆☆☆☆
    165 ☆☆☆☆☆☆☆☆☆
    166 
    167 1X1=1
    168 1X2=2    2X2=4
    169 1X3=3    2X3=6    3X3=9
    170 1X4=4    2X4=8    3X4=12    4X4=16
    171 1X5=5    2X5=10    3X5=15    4X5=20    5X5=25
    172 1X6=6    2X6=12    3X6=18    4X6=24    5X6=30    6X6=36
    173 1X7=7    2X7=14    3X7=21    4X7=28    5X7=35    6X7=42    7X7=49
    174 1X8=8    2X8=16    3X8=24    4X8=32    5X8=40    6X8=48    7X8=56    8X8=64
    175 1X9=9    2X9=18    3X9=27    4X9=36    5X9=45    6X9=54    7X9=63    8X9=72    9X9=81
    176 ************************************************
    177 下三角:
    178   document.write("<table border='1'>");
    179         for(var i=9;i>=1;i--){
    180             document.write("<tr>");
    181             for(var j=1;j<=i;j++){
    182                 document.write("<td>");
    183                 document.write(j+"X"+i+"="+i*j);
    184                 document.write("</td>");
    185             }
    186             document.write("</tr>");
    187         }
    188         document.write("</table>");
    189 1X9=9    2X9=18    3X9=27    4X9=36    5X9=45    6X9=54    7X9=63    8X9=72    9X9=81
    190 1X8=8    2X8=16    3X8=24    4X8=32    5X8=40    6X8=48    7X8=56    8X8=64
    191 1X7=7    2X7=14    3X7=21    4X7=28    5X7=35    6X7=42    7X7=49
    192 1X6=6    2X6=12    3X6=18    4X6=24    5X6=30    6X6=36
    193 1X5=5    2X5=10    3X5=15    4X5=20    5X5=25
    194 1X4=4    2X4=8    3X4=12    4X4=16
    195 1X3=3    2X3=6    3X3=9
    196 1X2=2    2X2=4
    197 1X1=1
    198 **********************************************
    199 计算出1—100之间所有不能被3整除的整数的和大于(或等于)2000的数字。
    200 var sum=0;
    201      for(var i=1;i<=100;i++){
    202          if(i%3!==0){
    203              sum+=i;
    204              if(sum>=2000){
    205                  document.write(sum+"<br>");
    206              }
    207          }
    208 
    209 ******************************************
    210 //计算出1到100之间所有不能被7整除的整数之和(用continue)
    211         var sum=0;
    212         for(var i=1;i<=100;i++){
    213             if(i%7===0){
    214                 continue;//4315
    215                 //break;//21  1+2+3+4+5+6=21
    216             }else{
    217                 sum+=i;
    218             }
    219         }
    220         alert(sum);
    221      }
    222 ******************************************
    223 //求1到100之间所有不能被3整除的整数的第一个大于2000的和
    224 var sum=0;
    225         for(var i=1;i<=100;i++){
    226             if(i%3===0){
    227                 continue;
    228                 }
    229                 sum+=i;
    230                 if(sum>2000){
    231                     
    232                     alert(sum);
    233                     break;
    234                 }
    235             }
    236 ***************************************
    237   //求200-300之间第一个能被7整数的数
    238            for(var i=200;i<=300;i++){
    239                     if(i%7===0){
    240                         alert(i);
    241                         break;
    242                     }
    243                     }
    244 ********************************************
    245 死循环(去掉注释就不死循环)
    246    var sum = 0;
    247    var i=1;
    248    while(true){
    249        sum+=i;
    250        i++;
    251       // if(i>100){
    252           // break;
    253        //}
    254    }
    255    alert(sum);
    256 ***************************************
    257     //一、求一组数中的所有数的和和平均值
    258         var a=[20,33,55];
    259         var sum=0;
    260         var avg=0;
    261         var l=a.length;
    262         for(var i=0;i<l;i++){
    263              sum+=a[i];
    264         }
    265        avg=sum/l;
    266        document.write(avg);
    267 ***********************************************
    268  //三、求一组数中的最大值和最小值 并给出位置;
    269   var a=[10,20,40,30];
    270   var max=a[0];//不能指定一个数为最大值[var max=0](除非是确定的情况下),应该用数组里面的值,a[0]即让数组第一个值作为比较的最大值.
    271   var maxaddress=0;
    272   var min=a[0];
    273   var minaddress=0;
    274   for(var i=0;i<a.length;i++){
    275       if(max<a[i]){
    276           max=a[i];
    277           maxaddress=i
    278       }
    279       if(min>a[i]){
    280           min=a[i];
    281           minaddress=i
    282       }
    283   }
    284   alert("最大数为"+max+"位置为第"+(maxaddress+1)+"个");
    285   alert("最小数为"+min+"位置为第"+(minaddress+1)+"个");
    286 *******************************************************
    287 <!DOCTYPE html>
    288 <html lang="en">
    289 <head>
    290     <meta charset="UTF-8">
    291     <title>Document</title>
    292     <script>
    293         //var a=new Array(-12,34,56,88,32,"aa","-34.33","-34.34",12.23);
    294         /*var a=new Array(prompt("请输入数字"));
    295         document.write(a);*/
    296         var b=prompt("请输入要比较的数,用\",\"号隔开");
    297         var a=new Array();
    298         a=b.split(",");
    299         // for(var j=0;j<a.length;j++){
    300         //          document.write(a[j]);
    301         // }
    302         alert(typeof(a)+"  JS数组本质是对象啊!!");//本质是对象 PHP数组就是数组,没有属性(比如length)
    303         document.write(a+"<br>");
    304         console.log(a+"<br>");
    305         var max=parseFloat(a[0]);
    306         //document.write(max);
    307         var maxaddress=0;
    308         var min=parseFloat(a[0]);
    309         var minaddress=0;
    310         
    311         for(var i=0;i<=a.length;i++){
    312             var shu=parseFloat(a[i]);
    313             if(shu>max){
    314                 max=shu;
    315                 maxaddress=i;
    316             }
    317             if(shu<min){
    318                 min=a[i];
    319                 minaddress=i;
    320             }
    321         }
    322         document.write("最大数为"+max+"位置为第"+(maxaddress+1)+"个"+"<br>");
    323         document.write("最小数为"+min+"位置为第"+(minaddress+1)+"个");
    324     </script>
    325 </head>
    326 <body>
    327     
    328 </body>
    329 </html>
    330 *************************************************
    331 
    332         //三、将字符串数组用|或其他符号分割
    333    var arr = ["吕超","赵云","典韦","关羽","马超","张飞"];
    334    var str = arr[0];
    335    var separator = "|";
    336   //为了避免第一个名字前有|,把第一个名字从数组中取出,赋值给str,然后在链接其他名字。
    337    for(var i=1;i<arr.length;i++){
    338        str += separator+ arr[i];
    339    }
    340    document.write(str);
    341 
    342 //即str=arr[0]+|+arr[1]+|+arr[2]+|......
    343 ****************************************************
    344  //四、将数组中值为0的去掉,不为0的存入一个新数组
    345    var arr=["吕超",0,"赵云","典韦",0,"关羽","马超",0,"张飞",0];
    346    var arr2=new Array();
    347    for(var i=0;i<arr.length;i++){
    348        if(arr[i]===0){
    349            continue;
    350        }else{
    351            arr2[arr2.length]=arr[i];//arr2.length是关键点
    352        }
    353    }
    354    document.write(arr2+"<br>");
    355 **********************************************
    356 
    357     //四、将数组中值为0的去掉,不为0的存入一个新数组
    358 //    var arr = [0,"刘备",0,"关羽",0,"张飞",0];
    359 //    var newArr = [];
    360 //    for(var i=0;i<arr.length;i++){
    361 //        //判断,如果不是0,放入新数组
    362 //        if(arr[i] !== 0){
    363 //            newArr[newArr.length] = arr[i];
    364 //        }
    365 //    }
    366 //    console.log(newArr);
    367 
    368 **************************************
      1 //五、翻转数组
      2 //思路:实现方法:1.定义一个新数组,把老数组中的元素从后往前添加到新数组中。
      3 ar arr = ["吕超","赵云","典韦","关羽","马超","张飞"];
      4 var arr2=new Array();
      5 for(var i=0;i<arr.length;i++){
      6 arr2[arr2.length]=arr[arr.length-1-i];//arr2.lenght是自增的从0开始 arr.length是知道的,arr.length-1-i就是这个数组的最后一个赋值给arr2的第一个(为什么要-1,因为数组从0开始计数的,length是大于最大数组的下标+1的)
      7 }
      8 document.write(arr2);
      9 
     10 扩展思维,第二种:
     11 var arr = ["吕超","赵云","典韦","关羽","马超","张飞"];
     12 var arr2=new Array();
     13 for(var i=arr.length-1;i>=0;i--){//直接自己就倒叙了,这样倒序的第一个进入arr2的正序第一个
     14 arr2[arr2.length]=arr[i];
     15 }
     16 document.write(arr2);
     17 
     18 拓展思维,第三种 
     19 //思路:实现方法:1.操作原数组,让原数组第一位和最后一个位调换位置,以此类推
     20 var arr = ["吕超","赵云","典韦","关羽","马超","张飞"];
     21 
     22 for(var i=0;i<arr.length/2;i++){//这里为什么/2 因为这个算法是首尾交换,执行到数组的一半的时候,首尾其实已经完成了 不/2 那么还会继续交换,又会返回为原先的数组 等于没有交换.
     23 var temp=arr[i];
     24 arr[i]=arr[arr.length-1-i];
     25 arr[arr.length-1-i]=temp;
     26 }
     27 document.write(arr);
     28 *****************************************************
     29 冒泡排序(双重for循环 第一个for控制轮数 第二个for控制次数 比较的轮数为数据个数-1 比较的次数为数据个数-1)
     30 <!DOCTYPE html>
     31 <html lang="en">
     32 <head>
     33 <meta charset="UTF-8">
     34 <title>Document</title>
     35 <script>
     36 var a=[45,67,23,88,21,6,99];
     37 var temp=[];
     38 var m=0;//轮数
     39 var n=0;//一共次数
     40 for(var i=0;i<a.length-1;i++){//这里不减1 后面轮数就+1 这是不对的 因为数组下标0开始
     41 for(var j=0;j<a.length-1;j++){
     42 if(a[j]>a[j+1]){//后面的大于前面的 后面再前 前面在后 从小到大
     43 temp=a[j];//a[j]=temp;
     44 a[j]=a[j+1];//a[j+1]=a[j];
     45 a[j+1]=temp;//a[j+1]=temp
     46 //顺序不能调换 因为a[]里面有个下标是一定从小到大的
     47 }
     48 n++
     49 }
     50 m++;
     51 }
     52 //document.write(a.length);
     53 document.write(a+"<br>");
     54 document.write("轮数"+m+"<br>");
     55 document.write("总次数"+n+"<br>");
     56 // a1 a2
     57 // 3 2
     58 // temp
     59 
     60 // 2 3
     61 // temp
     62 
     63 // 2 3 
     64 // temp
     65 
     66 
     67 // 第一轮 6次
     68 // 45 67 23 88 21 6 99
     69 // 45 23 67 88 21 6 99
     70 // 45 23 67 88 21 6 99
     71 // 45 23 67 21 88 6 99
     72 // 45 23 67 21 6 88 99
     73 // 45 23 67 21 6 88 99
     74 
     75 // 第二轮 6次
     76 // 23 45 67 21 6 88 99
     77 // 23 45 67 21 6 88 99
     78 // 23 45 21 67 6 88 99
     79 // 23 45 21 6 67 88 99
     80 // 23 45 21 6 67 88 99
     81 // 23 45 21 6 67 88 99
     82 
     83 // 第三轮 6次
     84 // 23 45 21 6 67 88 99
     85 // 23 21 45 6 67 88 99
     86 // 23 21 6 45 67 88 99
     87 // 23 21 6 45 67 88 99
     88 // 23 21 6 45 67 88 99
     89 // 23 21 6 45 67 88 99
     90 
     91 // 第四轮 6次
     92 // 21 23 6 45 67 88 99
     93 // 21 6 23 45 67 88 99
     94 // 21 6 23 45 67 88 99
     95 // 21 6 23 45 67 88 99
     96 // 21 6 23 45 67 88 99
     97 // 21 6 23 45 67 88 99
     98 
     99 // 第五轮 6次
    100 // 6 21 23 45 67 88 99
    101 // 6 21 23 45 67 88 99
    102 // 6 21 23 45 67 88 99
    103 // 6 21 23 45 67 88 99
    104 // 6 21 23 45 67 88 99
    105 // 6 21 23 45 67 88 99
    106 // 第六轮 6次(这个第6轮即使后面已经成型了 它还是按照程序走一遍)
    107 // 6 21 23 45 67 88 99
    108 // 6 21 23 45 67 88 99
    109 // 6 21 23 45 67 88 99
    110 // 6 21 23 45 67 88 99
    111 // 6 21 23 45 67 88 99
    112 // 6 21 23 45 67 88 99
    113 
    114 
    115 </script>
    116 </head>
    117 <body>
    118 
    119 </body>
    120 </html>
    121 ********************************
    122 冒泡排序优化://每轮比较少比较一次。(每一轮都会比较出一个最大值,然后后一轮没有必要再比较了,所以没比较一轮,就少比较一次。。。) j<a.length-1-i
    123 <!DOCTYPE html>
    124 <html lang="en">
    125 <head>
    126 <meta charset="UTF-8">
    127 <title>Document</title>
    128 <script>
    129 var a=[45,67,23,88,21,6,99];
    130 var temp=[];
    131 var m=0;//轮数
    132 var n=0;//一共次数
    133 for(var i=0;i<a.length-1;i++){//这里不减1 后面轮数就+1 这是不对的 因为数组下标0开始
    134 for(var j=0;j<a.length-1-i;j++){ //每轮比较少比较一次。(每一轮都会比较出一个最大值,然后后一轮没有必要再比较了,所以没比较一轮,就少比较一次。。。)
    135 if(a[j]>a[j+1]){//后面的大于前面的 后面再前 前面在后 从小到大
    136 temp=a[j];//a[j]=temp;
    137 a[j]=a[j+1];//a[j+1]=a[j];
    138 a[j+1]=temp;//a[j+1]=temp
    139 //顺序不能调换 因为a[]里面有个下标是一定从小到大的
    140 }
    141 n++
    142 }
    143 m++;
    144 }
    145 //document.write(a.length);
    146 document.write(a+"<br>");
    147 document.write("轮数"+m+"<br>");
    148 document.write("总次数"+n+"<br>");
    149 // a1 a2
    150 // 3 2
    151 // temp
    152 
    153 // 2 3
    154 // temp
    155 
    156 // 2 3 
    157 // temp
    158 
    159 45,67,23,88,21,6,99
    160 // 第一轮 6次
    161 // 45 67 23 88 21 6 99
    162 // 45 23 67 88 21 6 99
    163 // 45 23 67 88 21 6 99
    164 // 45 23 67 21 88 6 99
    165 // 45 23 67 21 6 88 99
    166 // 45 23 67 21 6 88 99
    167 
    168 // 第二轮 6次
    169 // 23 45 67 21 6 88 99
    170 // 23 45 67 21 6 88 99
    171 // 23 45 21 67 6 88 99
    172 // 23 45 21 6 67 88 99
    173 // 23 45 21 6 67 88 99
    174 // 23 45 21 6 67 88 99
    175 
    176 // 第三轮 6次
    177 // 23 45 21 6 67 88 99
    178 // 23 21 45 6 67 88 99
    179 // 23 21 6 45 67 88 99
    180 // 23 21 6 45 67 88 99
    181 // 23 21 6 45 67 88 99
    182 // 23 21 6 45 67 88 99
    183 
    184 // 第四轮 6次
    185 // 21 23 6 45 67 88 99
    186 // 21 6 23 45 67 88 99
    187 // 21 6 23 45 67 88 99
    188 // 21 6 23 45 67 88 99
    189 // 21 6 23 45 67 88 99
    190 // 21 6 23 45 67 88 99
    191 
    192 // 第五轮 6次
    193 // 6 21 23 45 67 88 99
    194 // 6 21 23 45 67 88 99
    195 // 6 21 23 45 67 88 99
    196 // 6 21 23 45 67 88 99
    197 // 6 21 23 45 67 88 99
    198 // 6 21 23 45 67 88 99
    199 // 第六轮 6次(这个第6轮即使后面已经成型了 它还是按照程序走一遍)
    200 // 6 21 23 45 67 88 99
    201 // 6 21 23 45 67 88 99
    202 // 6 21 23 45 67 88 99
    203 // 6 21 23 45 67 88 99
    204 // 6 21 23 45 67 88 99
    205 // 6 21 23 45 67 88 99
    206 
    207  
    208 
    209 // 第一轮 6次
    210 // 45 67 23 88 21 6 99
    211 // 45 23 67 88 21 6 99
    212 // 45 23 67 88 21 6 99
    213 // 45 23 67 21 88 6 99
    214 // 45 23 67 21 6 88 99
    215 // 45 23 67 21 6 88 99
    216 
    217 // 第二轮 5次
    218 // 23 45 67 21 6 88 99
    219 // 23 45 67 21 6 88 99
    220 // 23 45 21 67 6 88 99
    221 // 23 45 21 6 67 88 99
    222 // 23 45 21 6 67 88 99
    223 
    224 // 第三轮 4次
    225 // 23 45 21 6 67 88 99
    226 // 23 21 45 6 67 88 99
    227 // 23 21 6 45 67 88 99
    228 // 23 21 6 45 67 88 99
    229 
    230 // 第四轮 3次
    231 // 21 23 6 45 67 88 99
    232 // 21 6 23 45 67 88 99
    233 // 21 6 23 45 67 88 99
    234 
    235 
    236 // 第五轮 2次
    237 // 6 21 23 45 67 88 99
    238 // 6 21 23 45 67 88 99
    239 
    240 // 第六轮 1次
    241 // 6 21 23 45 67 88 99
    242 
    243 </script>
    244 </head>
    245 <body>
    246 
    247 </body>
    248 </html>
    249 ****************************
    250 冒泡排序优化2:5轮 5+4+3+2+1=11次
    251 做一个判断
    252 如果在比较的时候 两两不发生比较了 就退出循环 
    253 <!DOCTYPE html>
    254 <html lang="en">
    255 <head>
    256 <meta charset="UTF-8">
    257 <title>Document</title>
    258 <script>
    259 var a=[45,67,23,88,21,6,99];
    260 //var a=[1,2,3,4,5,6,7,8,9];
    261 var temp=[];
    262 var m=0;//轮数
    263 var n=0;//一共次数
    264 //如果比较完备提前结束比较。(判断,如果本次比较没有移动任何元素,那么说明已经比较完成)
    265 for(var i=0;i<a.length-1;i++){//这里不减1 后面轮数就+1 这是不对的 因为数组下标0开始
    266 //开闭原则。(写在第一个for循环里,是为了,每轮比较初始化bool变量变为true。)
    267 var bool=true;
    268 for(var j=0;j<a.length-1-i;j++){ //每轮比较少比较一次。(每一轮都会比较出一个最大值,然后后一轮没有必要再比较了,所以没比较一轮,就少比较一次。。。)
    269 if(a[j]>a[j+1]){//后面的大于前面的 后面再前 前面在后 从小到大
    270 temp=a[j];//a[j]=temp;
    271 a[j]=a[j+1];//a[j+1]=a[j];
    272 a[j+1]=temp;//a[j+1]=temp
    273 //顺序不能调换 因为a[]里面有个下标是一定从小到大的
    274 bool=false;
    275 n++;
    276 }
    277 
    278 }
    279 
    280 //bool这个变量默认值为true;如果本轮比较有一对元素相互交换位置,那么也不能跳出循环。
    281 //但是,如果本轮比较没有任何元素相互交换位置,那么说明已经比较完成,可以跳出循环。
    282 if(bool){
    283 break;
    284 }
    285 m++;
    286 }
    287 //document.write(a.length);
    288 document.write(a+"<br>");
    289 
    290 document.write("总次数"+n+"<br>");
    291 document.write("轮数"+m+"<br>");
    292 // a1 a2
    293 // 3 2
    294 // temp
    295 
    296 // 2 3
    297 // temp
    298 
    299 // 2 3 
    300 // temp
    301 
    302 
    303 // 第一轮 6次
    304 // 45 67 23 88 21 6 99
    305 // 45 23 67 88 21 6 99
    306 // 45 23 67 88 21 6 99
    307 // 45 23 67 21 88 6 99
    308 // 45 23 67 21 6 88 99
    309 // 45 23 67 21 6 88 99
    310 
    311 // 第二轮 6次
    312 // 23 45 67 21 6 88 99
    313 // 23 45 67 21 6 88 99
    314 // 23 45 21 67 6 88 99
    315 // 23 45 21 6 67 88 99
    316 // 23 45 21 6 67 88 99
    317 // 23 45 21 6 67 88 99
    318 
    319 // 第三轮 6次
    320 // 23 45 21 6 67 88 99
    321 // 23 21 45 6 67 88 99
    322 // 23 21 6 45 67 88 99
    323 // 23 21 6 45 67 88 99
    324 // 23 21 6 45 67 88 99
    325 // 23 21 6 45 67 88 99
    326 
    327 // 第四轮 6次
    328 // 21 23 6 45 67 88 99
    329 // 21 6 23 45 67 88 99
    330 // 21 6 23 45 67 88 99
    331 // 21 6 23 45 67 88 99
    332 // 21 6 23 45 67 88 99
    333 // 21 6 23 45 67 88 99
    334 
    335 // 第五轮 6次
    336 // 6 21 23 45 67 88 99
    337 // 6 21 23 45 67 88 99
    338 // 6 21 23 45 67 88 99
    339 // 6 21 23 45 67 88 99
    340 // 6 21 23 45 67 88 99
    341 // 6 21 23 45 67 88 99
    342 // 第六轮 6次(这个第6轮即使后面已经成型了 它还是按照程序走一遍)
    343 // 6 21 23 45 67 88 99
    344 // 6 21 23 45 67 88 99
    345 // 6 21 23 45 67 88 99
    346 // 6 21 23 45 67 88 99
    347 // 6 21 23 45 67 88 99
    348 // 6 21 23 45 67 88 99
    349 
    350  
    351 
    352 // 第一轮 6次
    353 // 45 67 23 88 21 6 99
    354 // 45 23 67 88 21 6 99
    355 // 45 23 67 88 21 6 99
    356 // 45 23 67 21 88 6 99
    357 // 45 23 67 21 6 88 99
    358 // 45 23 67 21 6 88 99
    359 
    360 // 第二轮 5次
    361 // 23 45 67 21 6 88 99
    362 // 23 45 67 21 6 88 99
    363 // 23 45 21 67 6 88 99
    364 // 23 45 21 6 67 88 99
    365 // 23 45 21 6 67 88 99
    366 
    367 // 第三轮 4次
    368 // 23 45 21 6 67 88 99
    369 // 23 21 45 6 67 88 99
    370 // 23 21 6 45 67 88 99
    371 // 23 21 6 45 67 88 99
    372 
    373 // 第四轮 3次
    374 // 21 23 6 45 67 88 99
    375 // 21 6 23 45 67 88 99
    376 // 21 6 23 45 67 88 99
    377 
    378 
    379 // 第五轮 2次
    380 // 6 21 23 45 67 88 99
    381 // 6 21 23 45 67 88 99
    382 
    383 // 第六轮 1次
    384 // 6 21 23 45 67 88 99
    385 
    386 </script>
    387 </head>
    388 <body>
    389 
    390 </body>
    391 </html> 
    392 // 第一轮 5次
    393 // 45 67 23 88 21 6 99
    394 // 45 23 67 88 21 6 99
    395 // 45 23 67 88 21 6 99
    396 // 45 23 67 21 88 6 99
    397 // 45 23 67 21 6 88 99
    398 
    399 
    400 // 第二轮 4次
    401 // 23 45 67 21 6 88 99
    402 // 23 45 67 21 6 88 99
    403 // 23 45 21 67 6 88 99
    404 // 23 45 21 6 67 88 99
    405 
    406 
    407 // 第三轮 3次
    408 // 23 45 21 6 67 88 99
    409 // 23 21 45 6 67 88 99
    410 // 23 21 6 45 67 88 99
    411 
    412 
    413 // 第四轮 2次
    414 // 21 23 6 45 67 88 99
    415 // 21 6 23 45 67 88 99
    416 
    417  
    418 
    419 // 第五轮 1次
    420 // 6 21 23 45 67 88 99
    421 
    422 
    423 // 第六轮 0次
    424 *******************************
    425 PHP冒泡排序
    426 $b=array('4','3','8','9','2','1');
    427 $len=count($b);//6
    428 第一种:
    429 for($k=0;$k<=$len;$k++)
    430 {
    431 for($j=$len-1;$j>$k;$j--){
    432 if($b[$j]<$b[$j-1]){
    433 $temp = $b[$j];
    434 $b[$j] = $b[$j-1];
    435 $b[$j-1] = $temp;
    436 }
    437 }
    438 }
    439 第二种:
    440 for($k=1;$k<$len;$k++)
    441 {
    442 for($j=0;$j<$len-$k;$j++){
    443 if($b[$j]>$b[$j+1]){
    444 $temp =$b[$j+1];
    445 $b[$j+1] =$b[$j] ;
    446 $b[$j] = $temp;
    447 }
    448 }
    449 }
    450 
    451 
    452 
    453  

     

    展开全文
  • 【动态规划】随机图

    2017-11-03 14:00:16
    n),他有千分之p的概率成为这张图中的一条边(i,j)。不同的边出现的概率是相互独立的。那么生一个至少含有一个大于等于4的连通块的图的概率是多少? 分析 贼难,不想分析 解法一:正难则反,对症下药 正难则...

    题目描述

      随机生成一张n个点的无向图。把他顶点标号为1~n。对于一个点对i,j(1 <= i < j <= n),他有千分之p的概率成为这张图中的一条边(i,j)。不同的边出现的概率是相互独立的。那么生一个至少含有一个大于等于4的连通块的图的概率是多少?

    分析

    贼难,不想分析

    解法一:正难则反,对症下药

    正难则反
       存在一个大于等于4的连通块的概率,等价于:1减去所有连通块都小于等于3的概率。 
       状态函数:
       f(i,j,k)表示i个点的图中,有大小为2的连通块j个,大小为3的连通块k个,大小为1的联通块有i-2*j-3*k个的概率。
       边界:
       f(0,0,0)=1;
       转移方程:
       刷表法——分析在f(i,j,k)的基础上新加入1个点的状态转移:
       情况1、若新点与前面i个点中任何一个都不连边,则状态转移成 f(i+1,j,k)+=f(i,j,k)*(1-p)^i
       情况2、若新点与前面i个点中任意一个大小为1的连通块 连一条边构成一个大小为2的连同块,则状态转移成:f(i+1,j+1,k)+=f(i,j,k)*(i-2*j-3*k)*p*(1-p)^(i-1)
       情况3、若新点与前面i个点中任意 两个 大小为1的连通块连一条边构成一个大小为3的连同块,则状态转移成:f(i+1,j,k+1)+=f(i,j,k)*C(i-2*j-3*k,2)*p*p*(1-p)^(i-2)
       情况4、若新点与前面i个点中任意一个大小为2的连通块连一条边构成一个大小为3的连同块,则状态转移成:f(i+1,j-1,k+1)+=f(i,j,k)*2*j*p*(1-p)^(i-1)
       情况5、若新点与前面i个点中任意一个大小为2的连通块连两条边构成一个大小为3的连同块(大小为2的连通块的两个点分别连一条边),则状态转移成:f(i+1,j-1,k+1)+=f(i,j,k)*j*p*(1-p)^(i-1)

       对不起我抄题解了

    解法二:正难则反+大佬就是不一样——%%%通解通法

    借鉴了某位超级大犇的算法,强的一p。

    f(i)表示i个结点能够连通的概率

    g(i)表示i个结点无法满足至少有一个连通块大于等于4的概率

    正难则反:先考虑加入结点不能使图连通。对于新加入的结点,分析:

    若它和已有的i-1个结点形成了一块大小为j的连通块,相当于从i-1个结点中选择j-1个出来和现在的这个结点形成连通块,那么形成的概率为f(j)*C(i-1,j-1) 

    要使这个连通块不连通,则剩下的i-j个结点和这个连通块里面的所有节点都不能连通,概率为((1-p)^(i-j))^j=(1-p)^(j*(i-j))

    所以说此时形成大小为j的连通块并且这i个结点不连通的概率:f(j)*C(i-1,j-1)*(1-p)^(j*(i-j)) 

    g(i)类似,在这j个结点不与外界连通的同时,剩下的i-j个结点的大小也不能大于等于4,所以概率为:f(j)*C(i-1,j-1)*(1-p)^(j*(i-j))*g(i-j)

    综上,f(i)=1-sum{f(j)*C(i-1,j-1)*(1-p)^(j*(i-j)) | 1<=j<i}

    g(i)=sum{f(j)*C(i-1,j-1)*(1-p)^(j*(i-j))*g(i-j) | 1<=j<=3}

    当然,i<=3时,就算这i个结点全部连通,都无法满足至少有一个连通块大于等于4,所以说此时g(i)+=f(i)

    但是当j*(i-j)很大的时候,(1-p)^(j*(i-j))会趋近于0,题目精度要求不高,取对数避免

    最终答案ans=1-g(n) 

    贴一下算法二的代码

    #include<iostream>
    #include<cmath>
    #include<cstring>
    #include<cstdio>
    #include<cctype>
    #include<cstdlib>
    #include<algorithm>
    #include<vector>
    #include<stack>
    #include<queue>
    #include<set>
    #include<map>
    using namespace std;
    const int maxn=105,maxm=10005;
    int n;
    double p;
    void workin(){
    	scanf("%d%lf",&n,&p);
    	p/=1000;
    	return;
    }
    double C[maxn][maxn],fact[maxn],epow[maxm];
    void ready(){
    	epow[0]=0;
    	for(int i=1;i<=10000;i++){
    		epow[i]=epow[i-1]+log(1-p);
    	}
    	fact[0]=fact[1]=0;
    	for(int i=2;i<=n;i++){
    		fact[i]=fact[i-1]+log(i);
    	}
    	for(int i=1;i<=n;i++){
    		for(int j=0;j<=i;j++){
    			C[i][j]=fact[i]-fact[j]-fact[i-j];
    		}
    	}
    	return;
    }
    double d[maxn],f[maxn];
    void dp(){
    	d[1]=f[1]=0;
    	for(int i=2;i<=n;i++){
    		double sum=0;
    		for(int j=1;j<i;j++){
    			sum+=exp(d[j]+C[i-1][j-1]+epow[j*(i-j)]);
    		}
    		d[i]=log(1-sum);
    		sum=0;
    		for(int j=1;j<i && j<=3;j++){
    			sum+=exp(d[j]+C[i-1][j-1]+epow[j*(i-j)]+f[i-j]);
    		}
    		f[i]=log(sum);
    		if(i<4){
    			f[i]=log(exp(f[i])+exp(d[i]));
    		}
    	}
    	return;
    }
    void solve(){
    	ready();
    	dp();
    	printf("%.4lf",1-exp(f[n]));
    	return;
    }
    int main(){
    	freopen("in.txt","r",stdin);
    	//freopen("out.txt","w",stdout);
    	workin();
    	solve();
    	return 0;
    }
    最后说一句,fuse123fuseTQL!!!!
    展开全文
  • (使用do-while循环实现课程名称和课程代号对照表2、本金10000元存入银行,年利率是千分之三。每过1年,将本金和利息相加作为新的本金。计算5年后,获得的本金是多少?(使用for循环实现3、求整数1~100的累加值,但...

    1、实现一个课程名称和课程代号的转换器:输入下表中的课程代号,输出课程的名称。用户可以循环进行输入,如果输入n就退出系统。(使用do-while循环实现

    课程名称和课程代号对照表

    2、本金10000元存入银行,年利率是千分之三。每过1年,将本金和利息相加作为新的本金。计算5年后,获得的本金是多少?(使用for循环实现

    3、求整数1~100的累加值,但要求跳过所有个位为3的数。(使用for循环实现

    4、输入一个正整数N,判断该数是不是质数,如果是质数输出"N是一个质数",否则输出"N不是质数"。提示:质数的含义:除了1和它本身不能被任何数整除。(使用for循环实现

    5、输入一个正整数,将该数的各位左右反转输出,即输入123,输出321。(使用while循环实现

    6、在屏幕上打印出n行的金字塔图案,如,若n=5,则图案如下: * *** ***** ****** *********

    7、打印出100~999之间的所有"水仙花数"。所谓"水仙花数",是指一个3位数,其各位数字立方和等于该数本身。例如:153是一个"水仙花数",因为153=13+53+33。

    8、幸运猜猜猜:游戏随机给出一个0~99(包括0和99)的数字,然后让你猜是什么数字。你可以随便猜一个数字,游戏会提示太大还是太小,从而缩小结果范围。经过几次猜测与提示后,最终推出答案。在游戏过程中,记录你最终猜对时所需要的次数,游戏结束后公布结果。

    积分对照表

    猜测次数最多20次。

    提示:

    (1) 产生0~99之间的随机数字:

    int number = (int)(Math.random()*100)

    (2) 使用for循环结构,其中循环计数器counter同时也记录你猜测的次数

    (3) 计算积分可以使用switch结构

    sgs_tc_news.php?req=cBp4v32LlzZPuf9DcwRnM_7KT_WFaJLkPEt8ziOFvt8=

    展开全文
  • 英文宽度大概只有汉字一半,标点符号大概只有汉字三分之 一宽,数字大概只有四分之一的宽度。而汉字本身又有二分字,和三分字。某些字,如“啊”, 字体小时可能独体字,字体大些,变为二分字,字体再大,又变为三...
  • 6、支持简单的分表,主要针对一定规则的分表,比如百分表、千分表,也可以自己指定分表后缀; 7、简单的单表查询(比如所有条件and或者or结构),基本实现0sql代码编写(类似HibernateTemplate ...
  • 程序员二进制计算器 v1.36

    热门讨论 2014-07-16 16:21:43
    对150种食品进行抽查,仅105种合格,合格率是多少: %2 105/150 = 70% (2)按万分比输出 %4 %4将结果按万分比格式输出,例如: %4 0.00314 = 31.4%% 四 运算符与函数 1-运算符与分类 所有运算符,一律不区分...
  • 虚假视频程序.rar

    2010-09-05 22:56:01
    就是用户转化率高于2500分之一的话就不会亏本。实际操作的转化率远远大于这个数目。一般投资100元购买流量收入大概在130元-250元之间浮动。影响转化率的还有很多方面,有交换链的质量问题(假如你购买的流量都假量...
  • 大话数据结构

    2018-12-14 16:02:18
    这样,所谓的判断某一年是否是闰年就变成了查找这个数组的某一项的值是多少的问题。 2.13总结回顾 37 2.14结尾语 38 愚公移山固然可敬,但发明炸药和推土机,可能更加实在和聪明。 第3章线性表 41 3.1开场白 42 ...
  • 不同系统对错误率的要求不同,但一般不超出千分之六,即成功率不低于99.4% 1.5.CPU 定义及解释 中央处理器一块超大规模的集成电路,一台计算机的运算核心(Core)和控制核心( Control Unit)。它的功能主要...
  • 不过我得坦白,在写作《自己动手写操作系统》的时候,我并不敢期待它能引起多少反响,一方面因为操作系统并不是时尚的话题,另一方面我也走在学习的路上,或许只是比读者早走了一小步而已。然而出乎我的意料,它...
  • 不过我得坦白,在写作《自己动手写操作系统》的时候,我并不敢期待它能引起多少反响,一方面因为操作系统并不是时尚的话题,另一方面我也走在学习的路上,或许只是比读者早走了一小步而已。然而出乎我的意料,它...
  • 这个项目控制了给DRAM参数使用DRAM频率的数值。同理,数值小性能高,但是对内存的质量也要求严格! DRAM RAS# to CAS# Delay: 这个项目可控制DRAM作用指令与读取/写入指令之间的延迟时间,有2,3,4几种选择。...
  • 联谐振晶体),高负载电容(并联谐振晶体)之分。在电路上的特征为:晶振 串一只电容跨接在IC 两只脚上的,则为串联谐振型;一只脚接IC,一只脚接地 的,则为并联型。如确实没有原型号,需要代用的可采取串联谐振型...
  • excel的使用

    2012-11-25 17:06:01
    #_k"克"” 可以看到,使用条件格式,千分符和均匀间隔指示符的组合,不用增加公式的数目就可以改进工作表的可读性和效率。另外,我们还可以运用自定义格式来达到隐藏输入数据的目的,比如格式";##;0"只显示...
  • 全书分4篇,共23章。第1篇技能学习篇,主要包括asp.net技术基础、c#语言基础、流程语句控制和数组、面向对象编程、常用服务器控件、内置对象、验证控件、ado.net数据库开发技术、数据控件的应用、web用户控件、asp...
  • answers: ['欠款金额是多少 ', '多少钱呢', '律师费诉讼费都非常少都很合理,一定要起诉。', '大概金额多少?', '需要看标的额和案情复杂程度,建议细致面谈'] ***************************************************...
  • 测试培训教材

    2014-04-01 12:10:48
    Win2003+SQLServerSp4+QC9.0安装示例 1、安装Windows Server 2003 Enterprise Edition、安装IIS邮件服务器 2、安装SQL Server 2000、打上补丁Sp4 安装好SQL Server 2000后注意启动SQLServer服务器 3、...
  • 全书分4篇,共23章。第1篇技能学习篇,主要包括asp.net技术基础、c#语言基础、流程语句控制和数组、面向对象编程、常用服务器控件、内置对象、验证控件、ado.net数据库开发技术、数据控件的应用、web用户控件、asp...
  • Oracle专家高级编程--详细书签版

    热门讨论 2012-08-21 11:57:09
    5.1.3 产生多少重做 132 5.1.4 能够不让重做日志产生吗 142 5.1.5 不能分配一个新日志 145 5.1.6 块清除 146 5.1.7 日志竞争 149 5.1.8 临时表和重做/回滚 151 5.1.9 分析重做 153 5.2 回滚 154 5.2.1 什么...
  • 然后结合官网文档细致地过一遍,学习过程中最好结合前人大牛的博客,都经验得你说要不要看。最后就是项目了,实际就是在工作中应用,这个我也说不好,每个人都有自己的方法吧。当然,深入看源码躲不过的,分享...
  • 4.绿化率多少合适 住宅小区绿化率标准 5.楼层净高 6.为什么每层住宅楼层默认高在 3 米左右? 7.杭州2017年的现房销售政策 8.3分钟!搞定杭州人才居住证! 9.买房选择东边套 西边套 还是中间套? 10.公摊面积 11....
  • 有幾個理由可以支持這點,一看潛在的回覆者有多少,二看觀眾有多少。黑客較願意回答那些能幫助到許多人的問題。 可以理解的,老練的黑客和一些熱門軟體的作者正在接受過多的錯發訊息。就像那根最後壓垮駱駝背...
  • 一个公司被称为市场系统的网状结构中一个小的组元。这个市场系统及它的组成物——那些商业公司,尤其取得高利润率的公司,经常受到激烈的抨击。由于商人们的目光往往只局限在市场系统中自己这一小部分,所以,...
  • 于2018-01-15,XXL-JOB参与"2017码云最火开源项目"评比,在当时已录入的约六五百个码云项目中角逐,最终进去了前20强。 于2018-04-14,iTechPlus在上海举办的 "2018互联网开发者大会",我登台对XXL-JOB做了演讲,...
  • 千里马酒店前台管理系统V7使用手册

    热门讨论 2011-06-16 14:09:38
    §第二章 快速入门 Quick Start 4 2.1 功能结构 5 2.2 功能特色 7 2.3 运行环境 9 2.4 安装启动 9 2.4.1 客户端安装 9 2.4.2 数据库安装 10 2.4.3 软件启动 11 2.4.4 数据初始化 13 2.4.5 数据转换 13 2.5 业务流程 ...

空空如也

空空如也

1 2
收藏数 33
精华内容 13
关键字:

千分之4是多少