[从头学数学] 第195节 计数原理

剧情提要：
[机器小伟]在[工程师阿伟]的陪同下进入了[九转金丹]之第五转的修炼。
这次要研究的是[计数原理]。

正剧开始：

星历2016年04月25日 10:22:16, 银河系厄尔斯星球中华帝国江南行省。
[工程师阿伟]正在和[机器小伟]一起研究[计数原理]。

<span style="font-size:18px;">	if (1) {  
        var r = 20;            
        config.setSector(1,10,1,1.5);              
        config.graphPaper2D(0, 0, r);            
        config.axis2D(0, 0,180, 2.8);              
                
        //坐标轴设定        
        var scaleX = 2*r, scaleY = 2*r;          
        var spaceX = 1, spaceY = 1;           
        var xS = -10, xE = 10;          
        var yS = -10, yE = 10;          
        config.axisSpacing(xS, xE, spaceX, scaleX, 'X');            
        config.axisSpacing(yS, yE, spaceY, scaleY, 'Y');         
              
		var array2D = [[0, 0]];
		
		for (var i = 2; i <=10; i+=2) {
			for (var j = -3; j <=3; j+=3) {
				array2D.push([i, j]);
			}
		}
          
		array2D.push([12, 0]);
          
        //去除重复点    
        var pointArray = removeDuplicatedPoint(array2D);    
        //无重复的点的数量    
        var points = pointArray.length;    
            
        //得到距离阵列    
        //格式为[[点1序号，点2序号, 距离值], ...]    
        var distanceArray = distanceSort(pointArray);    
        //边的数量    
        var edges = distanceArray.length;    
            
        //存放需要连通的边    
        var linkedArray = [];    
        //连通的边的数量    
        var links = 0;    
            
        //每个顶点相关的边的集合    
        var edgeOfVertex = [];    
            
        for (var i = 0; i < points; i++) {    
                
                
            //获得顶点相关的边的集合    
            edgeOfVertex = [];    
            for (var j = 0; j < edges; j++) {    
                if (distanceArray[j][0] == i ||    
                    distanceArray[j][1] == i) {    
                    edgeOfVertex.push(distanceArray[j]);    
                }    
            }    
                
            //根据起始点寻找最短长度的两条边    
            edgeOfVertex.sort(function(a, b) {    
                return a[2] - b[2];    
            });    
                
            var choice = 3;    
            if (edgeOfVertex.length > choice) {    
                edgeOfVertex = edgeOfVertex.slice(0, choice);    
            }    
                
            linkedArray = linkedArray.concat(edgeOfVertex);    
        }    
            
            
        //document.write(linkedArray.join(' , ')+'<br/>');    
        linkedArray = removeDuplicatedPoint(linkedArray);    
        links = linkedArray.length;    
            
        //document.write(linkedArray.join(' , ')+'<br/>');        
            
        var startPoint, endPoint, x1, y1, x2, y2;    
        //比例缩放    
        var scale = scaleX/spaceX;    
            
        for (var i = 0; i < links; i++) {    
            startPoint = linkedArray[i][0];    
            endPoint = linkedArray[i][1];    
            x1 = pointArray[startPoint][0];    
            y1 = pointArray[startPoint][1];    
            x2 = pointArray[endPoint][0];    
            y2 = pointArray[endPoint][1];    
                
            shape.vectorDraw([[x1,y1], [x2, y2]], 'red', scale);    
        }    
          
        shape.pointDraw(pointArray, 'blue', scale, 1, 'OABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnpqrstuvwxyz');  
          
    

          
    }</span>

小伟一直以来都想算一下车牌号容量，以了解某些地方为什么要限牌。

先看车牌编码规则：

代表该车所在地的地市一级代码，规律一般是这样的，A是省会，B是该省第二大城市，C是
该省第三大城市，依此类推。 车牌号的第一个是汉字：代表该车户口所在省的简称：如四
川就是川，北京就是京，重庆就是渝，上海就是沪......，第二个是英文：代表该车所在
地的地市一级代码，规律一般是这样的，A是省会，B是该省第二大城市，C是该省第三大城
市，依此类推。然后就是后五位啦，这后五位是这样的规律，如果你是第一个在该省该地
区上的第一个车牌，从理论上讲你车牌后五位就是00001，如果你是第8965位车主，你的车
牌的后五位理论上就应该是08965，如果车牌超过了数字的容量就是第100000万位时，就从
第一位开始用字母A，后面用0001至9999，用完后第一位改成B再跟0001至9999，依此类推
，也就是说如果车牌号越大说明车越新，前面的英文字母越靠后，说明车越新，这就是一
般规律。黄色牌号代表大车，兰牌代表小车，黑牌代表外资企业或者是大使馆的车,军车的
牌号是按军队的编法编的，与地方车不一样，但是都是白底红字，警车与地方车编法基本
相同，只是最后位数字不是数字而是改成了红色的警字。

这是小伟的初步估算：

<span style="font-size:18px;">#省名+市代号+5位数字，且第一位可以用字母
#不考虑有字母保留的情况
>>> 36*9999
359964

#第二位也可以用字母
>>> 26*26*999+99999
775323

#后五位中的两个字母可以随意放，但必须连续
>>> 4*26*26*999+99999
2801295

#后五位中的两个字母可以随意放，且可以不连续
>>> 10*26*26*999+99999
6853239</span>

也就是说如果满足上述的限制条件，一个城市最多只能有不到700万台车。

如果这个城市面积1000平方公里，每平方公里就有车7000辆。

随便往哪一站，眼睛一定能看到车。

只是这个计算事实上没有什么意义，发不发牌这事。。。

<span style="font-size:18px;">>>> 
[[1, 2, 3, 4], [1, 2, 4, 3], [1, 3, 2, 4], [1, 3, 4, 2], [1, 4, 2, 3], [1, 4, 3, 2], [2, 1, 3, 4], [2, 1, 4, 3], [2, 3, 1, 4], [2, 3, 4, 1], [2, 4, 1, 3], [2, 4, 3, 1], [3, 1, 2, 4], [3, 1, 4, 2], [3, 2, 1, 4], [3, 2, 4, 1], [3, 4, 1, 2], [3, 4, 2, 1], [4, 1, 2, 3], [4, 1, 3, 2], [4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 1, 2], [4, 3, 2, 1]]

def perm(array):
    if (len(array)<=1):
        return [array];

    r = [];
    for i in range(len(array)):
        #抽去array[i]
        s = array[:i]+array[i+1:];
        p = perm(s);
        for x in p:
            #array[i]置顶
            r.append(array[i:i+1]+x);
    return r;


def tmp():
    print(perm([1,2,3,4]));</span>

<span style="font-size:18px;">#排列公式
def arrangement(n, m):
    if n < m:
        return arrangement(m, n);
    else:
        factorial = 1;
        for i in range(n, n-m, -1):
            factorial*=i;
        return factorial;
    
def tmp():
    print(arrangement(10, 4));
    print(arrangement(18, 5));
    print(arrangement(18, 18)/arrangement(13, 13));</span>

<span style="font-size:18px;">>>> 
182
648

def tmp():
    print(arrangement(14,2));
    print(9*arrangement(9,2));</span>

<span style="font-size:18px;">>>> 
45.0
90

#排列公式
def arrangement(n, m):
    if n < m:
        return arrangement(m, n);
    else:
        factorial = 1;
        for i in range(n, n-m, -1):
            factorial*=i;
        return factorial;

#组合公式
def combination(n, m):
    if (n < m):
        return combination(m, n);
    else:
        return arrangement(n, m)/arrangement(m,m);
    
def tmp():
    print(combination(10,2));
    print(arrangement(10,2));</span>

<span style="font-size:18px;">>>> 
[64.0, -192.0, 240.0, -160.0, 60.0, -12.0, 1.0]

#排列公式
def arrangement(n, m):
    if n < m:
        return arrangement(m, n);
    else:
        factorial = 1;
        for i in range(n, n-m, -1):
            factorial*=i;
        return factorial;

#组合公式
def combination(n, m):
    if (n < m):
        return combination(m, n);
    else:
        return arrangement(n, m)/arrangement(m,m);
    
def tmp():
    a = [2, -1];
    N = 6;

    coefficient = [];

    for i in range(N+1):
        coefficient.append(a[0]**(N-i)*a[1]**i*combination(N, i));

    print(coefficient);</span>

<span style="font-size:18px;">>>> 
[1.0, 14.0, 84.0, 280.0, 560.0, 672.0, 448.0, 128.0]

def tmp():
    a = [1, 2];
    N = 7;

    coefficient = [];

    for i in range(N+1):
        coefficient.append(a[0]**(N-i)*a[1]**i*combination(N, i));

    print(coefficient);
	
>>> 
[1.0, -9.0, 36.0, -84.0, 126.0, -126.0, 84.0, -36.0, 9.0, -1.0]

def tmp():
    a = [1, -1];
    N = 9;

    coefficient = [];

    for i in range(N+1):
        coefficient.append(a[0]**(N-i)*a[1]**i*combination(N, i));

    print(coefficient);</span>

本节到此结束，欲知后事如何，请看下回分解。