腾讯2017暑期实习生编程题

给定一个字符串s，你可以从中删除一些字符，使得剩下的串是一个回文串。如何删除才能使得回文串最长呢？
输出需要删除的字符个数。

输入描述:

输入数据有多组，每组包含一个字符串s，且保证:1<=s.length<=1000.

输出描述:

对于每组数据，输出一个整数，代表最少需要删除的字符个数。

输入例子:

abcda

google

输出例子:

2
2

提到回文串，自然要利用回文串的特点，想到将源字符串逆转后，“回文串”（不一定连续）相当于顺序没变
    求原字符串和其反串的最大公共子串的长度（使用动态规划很容易求得），然后用原字符串的长度减去这个最大公共子串的长度就得到了最小编辑长度。

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
const int MAX = 1001;
int MaxLen[MAX][MAX]; //最长公共子序列，动态规划求法
int maxLen(string s1, string s2){
    int length1 = s1.size();
    int length2 = s2.size();
    for (int i = 0; i < length1; ++i)
        MaxLen[i][0] = 0;
    for (int i = 0; i < length2; ++i)
        MaxLen[0][i] = 0;
     
    for (int i = 1; i <= length1; ++i)
    {
        for (int j = 1; j <= length2; ++j)
        {
            if (s1[i-1] == s2[j-1]){
                MaxLen[i][j] = MaxLen[i-1][j - 1] + 1;
            }
            else
            {
                MaxLen[i][j] = max(MaxLen[i - 1][j], MaxLen[i][j - 1]);
            }
        }
    }
 
    return MaxLen[length1][length2];
}
 
int main(){
    string s;
    while (cin >> s){
        int length = s.size();
        if (length == 1){
            cout << 1 << endl;
            continue;
        }
        //利用回文串的特点
        string s2 = s;
        reverse(s2.begin(),s2.end());
        int max_length = maxLen(s, s2);
        cout << length - max_length << endl;
    }
    return 0;
}

小Q最近遇到了一个难题：把一个字符串的大写字母放到字符串的后面，各个字符的相对位置不变，且不能申请额外的空间。
你能帮帮小Q吗？

输入描述:

输入数据有多组，每组包含一个字符串s，且保证:1<=s.length<=1000.

输出描述:

对于每组数据，输出移位后的字符串。

输入例子:

AkleBiCeilD

输出例子:

kleieilABCD

#include <iostream>
#include <string.h>
using namespace std;
int main(){
    string s;
    while(cin >> s){
        if(s.length() >= 1 && s.length() <= 1000){
            for(int i = 0; i < s.length(); i++)
                if(s[i] >= 'a' && s[i] <= 'z')
                    cout << s[i];
            for(int i = 0; i < s.length(); i++)
                if(s[i] <= 'Z' && s[i] >= 'A')
                    cout << s[i];
            cout << endl;//开始没写这个老是通不过...
        }
    }
    return 0;
}

#include<iostream>
#include<string>
using namespace std;
 
bool isCap(char c)
{
    if (c >= 'A' && c <= 'Z')
        return true;
    else
        return false;
}
  
void mSwap(char &a, char &b)
{
    if (a != b)
    {
        a ^= b;
        b ^= a;
        a ^= b;
    }
}
  
int main()
{
    string s;
    while (cin >> s)
    {
        int len = s.size();
        int end = len;
        for (int i = 0; i<end; ++i)
        {
            if (isCap(s[i]))
            {
                int j = i;
                for (; j<len- 1; ++j)
                    mSwap(s[j], s[j + 1]);
                --end;
                --i;
            }
        }
        cout << s <<endl;
    }
    return 0;
}

//用STL的partition算法直接搞定
 
 
 
#include<iostream>
 
#include<algorithm>
 
using namespace std;
 
  
 
bool isLower(charc) {
 
    returnc>='a';
 
}
 
  
 
intmain() {
 
    string s;
 
    while(cin >> s) {
 
        stable_partition(s.begin(),s.end(),isLower);
 
        cout << s << endl;
 
    }
 
}

小Q今天在上厕所时想到了这个问题：有n个数，两两组成二元组，差最小的有多少对呢？差最大呢？

输入描述:

输入包含多组测试数据。 对于每组测试数据： N - 本组测试数据有n个数 a1,a2...an - 需要计算的数据 保证: 1<=N<=100000,0<=ai<=INT_MAX.

输出描述:

对于每组数据，输出两个数，第一个数表示差最小的对数，第二个数表示差最大的对数。

输入例子:

6
45 12 45 32 5 6

输出例子:

1 2

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void result(vector<int>&a, int n);
int main()
{
    int num;
    while (cin >> num)
    {
        int temp;
        vector<int>data;
        for (int i = 0; i < num; ++i)
        {
            cin >> temp;
            data.push_back(temp);
        }
        result(data, num);
    }
    return 0;
}
 
void result(vector<int>&a, int n)
{
    if (n > 1)
    {
        sort(a.begin(), a.end());
        int m1 = 1;
        int m2 = 1;
        for (int i = 0; i < n-1; ++i)
        {
            if (a[i + 1] != a[i])
                break;
            ++m1;
        }
        for (int i = n - 1; i > 0; --i)
        {
            if (a[i - 1] != a[i])
                break;
            ++m2;
        }
        int max = m1*m2;
 
        int min_temp = a[1] - a[0];
        int min = 0;
        for (int i = 2; i < n; ++i)
            if (a[i] - a[i - 1] < min_temp)
                min_temp = a[i] - a[i - 1];
        if (min_temp == 0)
        {
            for (int i = 1; i < n; ++i)
            {
                int j = i - 1;
                while (j >= 0 && a[j] == a[i])
                {
                    ++min;
                    --j;
                }
            }
        }
        else
        {
            for (int i = 1; i < n; ++i)
                if (a[i] - a[i - 1] == min_temp)
                    ++min;
        }
        cout << min << ' ' << max << endl;
    }
}