力扣一日两练（4）——第三大的数，两地调度

算法时间频度：

一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。

算法时间复杂度：

一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),存在一个正常数c使得fn*c>=T(n)恒成立。记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。

在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如T(n)=n^2+3n+4与T(n)=4n^2+2n+1它们的频度不同，但时间复杂度相同，都为O(n^2)。

按数量级递增排列，常见的时间复杂度有:

常数阶O(1),对数阶O(log2n)(以2为底n的对数，下同),线性阶O(n),

线性对数阶O(nlog2n),平方阶O(n^2)，立方阶O(n^3),...，

k次方阶O(n^k),指数阶O(2^n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。

算法空间复杂度：

与时间复杂度类似，空间复杂度是指算法在计算机内执行时所需存储空间的度量。记作:

S(n)=O(f(n))

算法执行期间所需要的存储空间包括3个部分:

• 算法程序所占的空间;
• 输入的初始数据所占的存储空间;
• 算法执行过程中所需要的额外空间。

在许多实际问题中，为了减少算法所占的存储空间，通常采用压缩存储技术。

题目：第三大的数

给定一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。要求算法时间复杂度必须是O(n)。

示例：

示例 1:

输入: [3, 2, 1]

输出: 1

解释: 第三大的数是 1.

示例 2:

输入: [1, 2]

输出: 2

解释: 第三大的数不存在, 所以返回最大的数 2 .

示例 3:

输入: [2, 2, 3, 1]

输出: 1

解释: 注意，要求返回第三大的数，是指第三大且唯一出现的数。
存在两个值为2的数，它们都排第二。

使用语言JavaScript：

/**
 * @param {number[]} nums
 * @return {number}
 */
var thirdMax = function(nums) {
    var max1=-Infinity,max2=-Infinity,max3=-Infinity;
    var er=[];
    for(var i=0;i<nums.length;i++){
        if(max1<nums[i]){
            max1=nums[i];
        }
    }
    for(var i=0;i<nums.length;i++){
        if(max2<nums[i] && nums[i]<max1){
            max2=nums[i];
        }
    }
    for(var i=0;i<nums.length;i++){
        if(max3<nums[i] && nums[i]<max2){
            max3=nums[i];
        }
    }
    if(max3==-Infinity){
        return max1;
    }else{
        return max3;
    }   
};

分析：

因为要求返回第三大的数，是指第三大且唯一出现的数。 存在两个值为2的数，它们都排第二。所以我的想法是求出第一大、第二大和第三大的数值，我们可以通过for循环来求出数组最大值。而数组第二大值就是小于最大值之后的数。注意，在定义时需要将三个值都定义为负无穷大。

 

题目：两地调度

公司计划面试 2N 人。第 i 人飞往 A 市的费用为 costs[i][0]，飞往 B 市的费用为 costs[i][1]。

返回将每个人都飞到某座城市的最低费用，要求每个城市都有 N 人抵达。

示例：

输入：[[10,20],[30,200],[400,50],[30,20]]
输出：110
解释：
第一个人去 A 市，费用为 10。
第二个人去 A 市，费用为 30。
第三个人去 B 市，费用为 50。
第四个人去 B 市，费用为 20。

最低总费用为 10 + 30 + 50 + 20 = 110，每个城市都有一半的人在面试。

提示：

1. 1 <= costs.length <= 100
2. costs.length 为偶数
3. 1 <= costs[i][0], costs[i][1] <= 1000

使用语言JavaScript：

/**
 * @param {number[][]} costs
 * @return {number}
 */
var twoCitySchedCost = function(costs) {
    var n=costs.length/2;
    var max=0,sum=0,c1=0,c2=0;
    var er=[];
    for(var i=0;i<costs.length-1;i++){      
        for(var j=i+1;j<costs.length;j++){
            c1=costs[i][0]-costs[i][1];
            c2=costs[j][0]-costs[j][1];
            if(c1<c2){
                er=costs[j];
                costs[j]=costs[i];
                costs[i]=er;
            }
        }
        
    }
    for(var i=0;i<n;i++){
        sum=sum+costs[i][1];
        sum=sum+costs[i+n][0];
    }
    return sum;
};

分析：

该问题我一开始并没有完整的思路，后来在网上看到说要用贪心算法才明白的，所以只需要将costs的A\B两城市之间的费用差进行排序即可，我用去A城费用减去去B城费用。因为人数为偶数，所以只需把排完序的前一半人全部去B城，后一半人全部去A城即可完成。