算法——简单篇

最新推荐文章于 2024-10-02 22:45:05 发布

泽特即是本尊

最新推荐文章于 2024-10-02 22:45:05 发布

阅读量134

点赞数

分类专栏：算法文章标签：算法

本文链接：https://blog.csdn.net/udahci/article/details/90726722

版权

算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.尾部的0

class Solution {
public:
    /*
     * @param n: A long integer
     * @return: An integer, denote the number of trailing zeros in n!
     */
    long long trailingZeros(long long n) {
        if(n<5)
        return 0;
        else
        return (n/5+trailingZeros(n/5));
}
};

算法分析：设n!尾部0的数量的函数为F(n)
易得尾部0的数量由n！中2和5的因数数量决定，因为2的因数很多很多，故只需要考虑有几个5；
F(1)=0;F(2)=0;F(3)=0;F(4)=0;
F(5)=1…
F(n)=5k*5(k-1)*5(k-2)…5*1*A 其中k,A是正整数,且A不能被5整除
=5^k *A * k!
=5^k * A *F(k)
F(n)=k+F(k);
即F(n)=n/5+F(n/5);
将其转换为递归算法即可

丑数II

class Solution {
public:
	int nthUglyNumber(int n) {
        int num[n+1];
         int p2,p3,p5;
         p2=p3=p5=0;
         num[0]=1;

        for(int i=1;i<n;i++)
        {
            num[i]=min(min(num[p2]*2,num[p3]*3),min(num[p2]*2,num[p5]*5));
            if(num[i]==num[p2]*2)
                ++p2;
            if(num[i]==num[p3]*3)
                ++p3;
            if(num[i]==num[p5]*5)
                ++p5;
        }
        return num[n-1];

    }
    
};
int min(int a,int b){
    return (a<b)?a:b;
}

原来我本来打算直接用暴力的办法，即：遍历所有正整数，把符合条件的丑数挑出来，判断条件为：

bool IsUgly(int number)
{   while (number % 2 == 0)
        number /= 2;
    while (number % 3 == 0)
        number /= 3;
    while (number % 5 == 0)
        number /= 5;
    return (number == 1) ? 1 : 0;
}

但是由于正整数集实在太大，耗费的时间过多，所以只能考虑一个一个来生成
通过观察序列：1,2,3,4,5,6,8,9,10,12…
发现每个数必定是由前面的数乘“2，3或5”乘出来的。但要求从小到大排列，于是考虑到，在第i个数乘2，3，或5之后比较他们的大小，较小的那个存入数组。该模型可以理解为，以1为根节点，2，3，5为子节点的一个树结构，不过只需要按照从小到大排列即可

第k大元素

失败尝试

class Solution {
public:

    int kthLargestElement(int n, vector<int> &nums) {
     int len=nums.size();
     int max=nums.front();
     int flag=0,temp=0;
     
     for(int j=0;j<n;j++){
         for(int i=0;i<len-j;i++)
         {
             if(nums[i]>max)
             {max=nums[i];
             flag=i;
                
             }
         }
             temp=nums[len-1-j];
             nums[len-1-j]=nums[flag];
             nums[flag]=temp; 
         max=0;
     }
    return nums[len-n];
     
    }
};

这个想法是：遍历n次，每一次都找出最大的值，并把其位置保存在flag里面，把nums[flag]和nums.back() 交换（最大的和最后一个交换），循环n次后输出倒数第n个即可
但是

当n非常大是，time out