腾讯2017暑期实习生编程题目

构造回文：

题目：
给定一个字符串s，你可以从中删除一些字符，使得剩下的串是一个回文串。如何删除使得回文串最长呢？输出需要删除的字符个数。
输入描述:输入数据有多组，每组包含一个字符串s，且保证:1<=s.length<=1000.
输出描述:对于每组数据，输出一个整数，代表最少需要删除的字符个数。
输入例子: abcda google
输出例子: 2 2

思路
求原字符串翻转之后的字符串跟原字符串的最长公共子序列（可以不连续)，这里采用动态规划的方法，利用一个二维矩阵记录当前未知的最大公共子序列的长度。
注意：
1 memset以字节为单位填充，一般对字符型变量的初值进行赋值。常用于内存空间初始化。如：char str[100]；memset(str,0,100);
void * memset(void *s,int c,size_t n)，将已开辟内存空间 s 的首 n 个字节的值设为值 c。

2 bits/stdc++.h包括了所有的那些vector，string，之类的头文件，比较方便实用。

#include <iostream>
#include <string>
#include <memory.h>
#include<algorithm>
using namespace std;
int dp[1001][1001];

int LCS(string str){
    int len = str.length();
    memset(dp,0,sizeof(dp));
    string revStr(str);
    reverse(revStr.begin(),revStr.end());
    for(int i=0;i<len;++i){
        for(int j=0;j<len;++j){
            if(str[i]==revStr[j]) dp[i+1][j+1] = dp[i][j] + 1;
            else dp[i+1][j+1] = max(dp[i+1][j], dp[i][j+1]);
        }
    }
    return len-dp[len][len];
}

int main(){
    string str;
    while(cin>>str){
        cout<<LCS(str)<<endl;
    }
    return 0;
}

字符串移动

题目：小Q最近遇到了一个难题：把一个字符串的大写字母放到字符串的后面，各个字符的相对位置不变，且不能申请额外的空间。
输入描述:
输入数据有多组，每组包含一个字符串s，且保证:1<=s.length<=1000.
输出描述:
对于每组数据，输出移位后的字符串。
输入例子:AkleBiCeilD
输出例子:kleieilABCD

思路
排序算法（冒泡修改）

#include <iostream>
#include <string>
using namespace std;
int main(){
    string str;
    while(cin>>str){
        int len = str.length();
        int limit = len - 1;
        for(int i = len-1;i>=0;--i){
            if(str[i]>='A'&&str[i]<='Z'){
                char tmp = str[i];
                int k = i;
                for(;k<limit;++k)
                    str[k] = str[k+1];
                str[k] = tmp;
                --limit;
            }
        }
        cout<<str<<endl;
    }
}

3有趣的数字

题目：
小Q今天在上厕所时想到了这个问题：有n个数，两两组成二元组，差最小的有多少对呢？差最大呢？
输入描述 :
输入包含多组测试数据。对于每组测试数据：
N - 本组测试数据有n个数，a1, a2…an - 需要计算的数据
保证 :1 <= N <= 100000, 0 <= ai <= INT_MAX.
输出描述 :
对于每组数据，输出两个数，第一个数表示差最小的对数，第二个数表示差最大的对数。

思路：
先排序，再统计，时间复杂度是nlogn。
算差最大的对数就是最小的个数乘以最大数的个数，算差最小的对数不能仅仅只看相邻的两个数，因为有重复的数存在时不相邻的数字差值也是最小。所以遍历的时候是需要比较当前数字和当前数字前面的数字，如果差值不等于最小值，直接跳出；如果等于最小值，继续向前寻找。
区分特殊情况：如果n<1和所有数字都相同的时候。

#include <bits/stdc++.h>  
using namespace std;  

int main() {  
    int n;  
    while(cin>>n) {  
        vector<int> a(n);  
        for(int i = 0; i < n; ++i) {  
            cin >> a[i];  
        }  

        if(n == 1) {  
            cout << 0 << ' ' << 0 << endl;  
            continue;  
        }  

        sort(a.begin(), a.end());  

        if(a[0] == a[n - 1]) { //如果全部数字都相同  
            int ans = (n * (n - 1))/2;  
            cout << ans << ' ' << ans << endl;  
            continue;  
        }  

        int min_num = count(a.begin(), a.end(), a[0]);  
        int max_num = count(a.begin(), a.end(), a[n-1]);  
        int max_ans = min_num * max_num;  


        int min_value = a[1] - a[0];  
        for(int i = 1; i < n; ++i) {  
            if(a[i] - a[i-1] < min_value) min_value = a[i] - a[i-1];  
                    }  
        int min_ans = 0;  
        for(int i = 1; i < n; ++i) {  
            for(int j = i - 1; j >= 0; --j) {  
                if(a[i] - a[j] == min_value) ++min_ans;  
                else break;  
            }  
        }  

        cout << min_ans << ' ' << max_ans << endl;  
    }  
    return 0;  
}