• 寻找最小的k个数


    1 使用从大到小的优先队列保存最小的K个数,每次取出K个数之后的其余数和堆顶元素比较,如果比堆顶元素小,则将堆顶元素删除,将该元素插入

    复制代码
    void topK(int arr[],int n,int k)
    {
        if(k>n)
            return;
        priority_queue<int> q;
        for(int i=0;i<n;++i)
        {
            if(q.size()<k)
                q.push(arr[i]);
            else
            {
                if(arr[i]<q.top())
                {
                    q.pop();
                    q.push(arr[i]);
                }
            }
        }
        while(!q.empty())
        {
            cout<<q.top()<<' ';
            q.pop();
        }
        cout<<endl;
    }
    复制代码

    2 使用set的排序功能,以从大到小的顺序排序所有前K个元素,取出其余的元素与第一个元素比较,如果小于第一个元素,则将第一个元素删除,将当前元素插入。

    复制代码
    void topK1(int arr[],int n,int k)
    {
        set<int,greater<int> > st;
        if(k>n)
            return;
        for(int i=0;i<n;++i)
        {
            if(st.size()<k)
                st.insert(arr[i]);
            else
            {
                auto iter=st.begin();
                if(*iter>arr[i])
                {
                    st.erase(iter);
                    st.insert(arr[i]);
                }
            }
        }
        auto iter=st.begin();
        while(iter!=st.end())
        {
            cout<<*iter++<<' ';
        }
        cout<<endl;
    }
    复制代码

    3 使用partition的方法,每次找出一个数的固定位置index,其中左边的元素都比该元素小,右边的元素都比该元素大。如果index==k-1,则结束循环,找出的index及之前的元素就是k个最小的元素,否则如果index

    大于k-1,则需要找的元素在index的左边,否则需要找的元素在index的右边。循环查找直到index==k-1。

    复制代码
    int partition(int arr[],int s,int e)
    {
        int priov=arr[e];
        int i=s-1;
        int j=s;
        for(;j<e;++j)
        {
            if(arr[j]<priov)
            {
                ++i;
                swap(arr[i],arr[j]);
            }
        }
        ++i;
        swap(arr[i],arr[e]);
        return i;
    }
    void topK2(int arr[],int n,int k)
    {
        int index=partition(arr,0,n-1);
        while(index!=k-1)
        {
            if(index<k-1)
                index=partition(arr,index+1,n-1);
            else
                index=partition(arr,0,index-1);
        }
        for(int i=0;i<k;++i)
            cout<<arr[i]<<' ';
        cout<<endl;
    }
    复制代码

    4 利用选择排序的功能,n个元素中找出最小值与第一个元素交换,从n-1个元素中找出次小值与第二个元素交换,直到找到k个元素位置。

    复制代码
    void topK3(int arr[],int n,int k)
    {
        for(int i=0;i<k;++i)
        {
            int min=i;
            int j=i+1;
            while(j<n)
            {
                if(arr[j]<arr[min])
                    min=j;
                ++j;
            }
            if(min!=i)
                swap(arr[min],arr[i]);
        }
        for(int i=0;i<k;++i)
            cout<<arr[i]<<' ';
        cout<<endl;
    }
     
     

    去除字符串中重复字符

    题目

    设计算法并写出代码移除字符串中重复的字符,不能使用额外的缓存空间。注意: 可以使用额外的一个或两个变量,但不允许额外再开一个数组拷贝。

    进一步地,

    为你的程序写测试用例。

    解答

    这道题目其实是要你就地(in place)将字符串中重复字符移除。你可以向面试官问清楚, 不能使用额外的一份数组拷贝是指根本就不允许开一个数组,还是说可以开一个固定大小, 与问题规模(即字符串长度)无关的数组。

    如果根本就不允许你再开一个数组,只能用额外的一到两个变量。那么,你可以依次访问 这个数组的每个元素时间复杂度为O(n2 ),代码如下:

    复制代码
    #include<iostream>
    #include<cstring>
    using namespace std;
    
    void removeDuplicate(char *str)
    {
        if(str==NULL)
            return;
        int count=0;
        int n=strlen(str);
        for(int i=1;i<n;++i)
        {
            int j=i-1;
            while(j>=0)
            {
                if(str[i]==str[j])
                {
                    ++count;
                    break;
                }
                else
                    --j;
            }
            if(j<0)
                str[i-count]=str[i];
        }
        str[n-count]='';
    }
    
    int main()
    {
        char str[]="";
        removeDuplicate(str);
        cout<<str<<endl;
    }
    复制代码

    如果可以开一个固定大小,与问题规模(即字符串长度)无关的数组,那么可以用一个数组来 表征每个字符的出现(假设是ASCII字符,则数组大小为256),这样的话只需要遍历一遍字符 串即可,时间复杂度O(n)。代码如下:

    复制代码
    void removeDuplicate(char s[])
    {
        int len = strlen(s);
        if(len < 2) return;
        bool c[256];
        memset(c, 0, sizeof(c));
        int p = 0;
        for(int i=0; i < len; ++i)
        {
            if(!c[s[i]])
            {
                s[p++] = s[i];
                c[s[i]] = true;
            }
        }
        s[p] = '';    
    }


    数组分割

    一、题目概述:有一个没有排序,元素个数为2N的正整数数组。要求把它分割为元素个数为N的两个数组,并使两个子数组的和最接近。
    假设数组A[1..2N]所有元素的和是SUM。模仿动态规划解0-1背包问题的策略,令S(k, i)表示前k个元素中任意i个元素的和的集合。显然:
    S(k, 1) = {A[i] | 1<= i <= k}
    S(k, k) = {A[1]+A[2]+…+A[k]}
    S(k, i) = S(k-1, i) U {A[k] + x | x属于S(k-1, i-1) }
    按照这个递推公式来计算,最后找出集合S(2N, N)中与SUM/2最接近的那个和,这便是答案。这个算法的时间复杂度是O(2^N).
    因为这个过程中只关注和不大于SUM/2的那个子数组的和。所以集合中重复的和以及大于SUM/2的和都是没有意义的。把这些没有意义的和剔除掉,剩下的有意义的和的个数最多就是SUM/2个。所以,我们不需要记录S(2N,N)中都有哪些和,只需要从SUM/2到1遍历一次,逐个询问这个值是不是在S(2N,N)中出现,第一个出现的值就是答案。我们的程序不需要按照上述递推公式计算每个集合,只需要为每个集合设一个标志数组,标记SUM/2到1这个区间中的哪些值可以被计算出来。关键代码如下:

    复制代码
    #include<iostream>
    using namespace std;
    
    //有一个没有排序,元素个数为2N的正整数数组。要求把它分割为元素个数为N的两个数组,并使两个子数组的和最接近。
    int arr[] = {0,1,5,7,8,9,6,3,11,20,17};
    const int N=5;
    const int SUM = 87;
    
    // 模仿动态规划解0-1背包问题的策略
    int solve1()
    {
        int i , j , s;
        int dp[2*N+1][N+1][SUM/2+2];
    
        /*
        用dp(i,j,c)来表示从前i个元素中取j个、且这j个元素之和不超过c的最佳(大)方案,在这里i>=j,c<=S
        状态转移方程:   
        限第i个物品       不取  
        dp(i,j,c)=max{dp(i-1,j-1,c-a[i])+a[i],dp(i-1,j,c)}
        dp(2N,N,SUM/2+1)就是题目的解。
        */
        //初始化
        memset(dp,0,sizeof(dp));
    
        for(i = 1 ; i <= 2*N ; ++i)
        {
            for(j = 1 ; j <= min(i,N) ; ++j)
            {
                for(s = SUM/2+1 ; s >= arr[i] ; --s)
                {
                    dp[i][j][s] = max(dp[i-1][j-1][s-arr[i]]+arr[i] , dp[i-1][j][s]);
                }
            }
        }
    
        //因为这为最终答案 dp[2*N][N][SUM/2+1];
        i=2*N , j=N , s=SUM/2+1;
        while(i > 0)
        {
            if(dp[i][j][s] == dp[i-1][j-1][s-arr[i]]+arr[i])   //判定这个状态是由哪个状态推导出来的
            {
                cout<<arr[i]<<" ";    //取中arr[i]
                j--;
                s -= arr[i];
            }    
            i--;
        }
        cout<<endl;
        return dp[2*N][N][SUM/2+1];
    }
    
    int solve2()
    {
        int i , j , s;
        int dp[N+1][SUM/2+2];     //取N+1件物品,总合不超过SUM/2+2,的最大值是多少 
        memset(dp,0,sizeof(dp));    //初始状态都为0
    
        for(i = 1 ; i <= 2*N ; ++i)
        {
            for(j = 1 ; j <= min(i,N) ; ++j)
            {
                for(s = SUM/2+1 ; s >= arr[i] ; --s)    //01背包从大到小,可以省空间,即最外层的空间
                {
                    dp[j][s] = max(dp[j-1][s-arr[i]]+arr[i] , dp[j][s]); 
                }
            }
        }
        //要求最优解则 空间不能优化,
        return dp[N][SUM/2+1];
    }
    
    int solve3()
    {
        int i , j , s;
        int isOK[N+1][SUM/2+2]; //isOK[i][v]表示是否可以找到i个数,使得它们之和等于v
        memset(isOK,0,sizeof(isOK));    //都不合法
        //注意初始化
        isOK[0][0] = 1; //可以,取0件物品,总合为0,是合法的
    
        for(i = 1 ; i <= 2*N ; ++i)
        {
            for( j = 1 ; j <= min(i,N) ; ++j)
            {
                for(s = SUM/2+1 ; s >= arr[i] ; --s) //从大到小,数组少了一维
                {
                    if( isOK[j-1][s-arr[i]] )
                        isOK[j][s] = 1;
                }
            }
        }
        for(s = SUM/2+1 ; s >= 0 ; --s)
        {
            if(isOK[N][s])
                return s;
        }
    
        //要求最优解则空间不能优化
        return 0;
    }
    s3="<<s3<<endl;
        system("pause");
        return 0;
    }
    
    
    int main(void)
    {
        int s1 = solve1();
        int s2 = solve2();
        int s3 = solve3();
        cout<<"s1="<<s1<<endl;
        cout<<"s2="<<s2<<endl;
        cout<<"s3="<<s3<<endl;
        system("pause");
        return 0;
    }
     
  • 相关阅读:
    Mishka and Interesting sum
    Tree Restoring
    LIB 配置文件读写器
    WCF 采用net.tcp协议实践
    MVC ViewEngineResult实际上是一种设计
    MVC 依赖注入扩展
    功能权限设计
    代理上网荟萃
    MD5算法 简介
    MVC _ViewStart文件的作用
  • 原文地址:https://www.cnblogs.com/alantu2018/p/8462193.html
Copyright © 2020-2023  润新知