寻找最小的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]='\0'; } 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]; //取Ｎ+１件物品，总合不超过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; }