算法练习

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

输入描述:

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




输出描述:

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

示例1
输入
abcda
google
输出
2
2

我开始使用递归做的==》但是超时了

import java.util.Scanner;

public class T1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()){
           String str =  sc.nextLine();
           int numVal = 0;

           char[] arr = str.toCharArray();
           int low = 0;
           int high = arr.length - 1;
           numVal= numOfDelete(arr,low,high,numVal);
           System.out.println(numVal);
        }
    }

    private static int numOfDelete(char[] arr, int low, int high,int numVal) {
        if(low >= high){
            return numVal;
        }
        if(arr[low] == arr[high]){
            low++;
            high--;
            return numOfDelete(arr,low,high,numVal);
        }else {
            int newNum = numVal + 1;//注意这里不能使用++符号，因为下面还要使用原来的值
            int newlow = low + 1;
            int newhigh = high;
            int a = numOfDelete(arr,newlow,newhigh,newNum);

             newlow = low;
             newhigh = high - 1;
            int b = numOfDelete(arr,newlow,newhigh,newNum);

            newNum = numVal + 2;
            newlow = low + 1;
            newhigh = high - 1;
            int c = numOfDelete(arr,newlow,newhigh,newNum);
            return Math.min(Math.min(a,b),c);
        }
    }
}

但终归还是学会了点=》看注意。 
别人的做法：可以把源字符串进行反转，然后作为回文部分的串其实没有发生变化，所以可以求两个字符串的最长公共子序列，然后减去它的长度即可。 
所以呢，代码如下;

import java.util.Scanner;

public class T1again {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()){
            String str =  sc.nextLine();
            char[] arr = str.toCharArray();
            int i=0,j=arr.length-1;
            while(i < j){
                char tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
                i++;
                j--;
            }
            String str2 = new String(arr);

            int numVal= LCS(str,str2);
            System.out.println(str.length() - numVal);
        }
    }
    public static int LCS(String s1,String s2){
        int len1 = s1.length();
        int len2 = s2.length();
        int[][] arr = new int[len1+1][len2+1];//注意这里申请的长度是len1+1和len2+1
        for(int i=1;i<=len1;i++){
            for(int j=1;j<=len2;j++){
                if(s1.charAt(i-1) == s2.charAt(j-1)){
                    arr[i][j] = arr[i-1][j-1] + 1;
                }else {
                    arr[i][j] = Math.max(arr[i-1][j],arr[i][j-1]);
                }
            }
        }
        return arr[len1][len2];
    }
}

注意： 
arrr[i][j]表示str1前i个字符和str2前j个字符的最长公共子序列长度，它需要i-1和j-1这里的判断，所以肯定要从i=1，j=1开始，判断第i-1和j-1个元素是不是相等。然后申请的数组长度也就是是len1+1和len2+1了。 
返回值也特殊了。

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


输入描述:

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




输出描述:

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


输入例子1:
AkleBiCeilD

输出例子1:
kleieilABCD

import java.util.Scanner;

public class Test{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while (sc.hasNext()) {
            String str = sc.nextLine();
            System.out.println(str.replaceAll("[A-Z]","")+str.replaceAll("[a-z]",""));
        }
    }
    
}

我比较暴力，直接申请一个数组多次循环搞定了。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()){
            String str =  sc.nextLine();
            char[] arr = str.toCharArray();
            char[] list = new char[arr.length];
            int count = 0;
            for(int i=0;i<arr.length;i++){
                if(arr[i]>='a' && arr[i]<='z'){
                    list[count++] = arr[i];
                }
            }

            for(int i=0;i<arr.length;i++){
                if(arr[i]>='A' && arr[i]<='Z'){
                    list[count++] = arr[i];
                }
            }

            String s = new String(list);
            System.out.println(list);

        }
    }
}

如果不使用额外空间： 
https://blog.csdn.net/zhangtaozaqaq/article/details/42122149

或者;

//冒泡排序思想  AkleBiCeilD 赞
#include<iostream>
#include<string>
using namespace std;
int main(){
    string s;
    while(cin>>s){
        for(int i=0;i<s.size()-1;i++)
            for(int j=0;j<s.size()-1-i;j++)
                if((s[j]>='A'&&s[j]<='Z')&&(s[j+1]<'A'||s[j+1]>'Z')){
                    char c=s[j];
                    s[j]=s[j+1];
                    s[j+1]=c;
                }
     cout<<s<<endl;
    }
}

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


输入描述:

 输入包含多组测试数据。

 对于每组测试数据：

 N - 本组测试数据有n个数

 a1,a2...an - 需要计算的数据

 保证:

 1<=N<=100000,0<=ai<=INT_MAX.




输出描述:

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

示例1
输入
6
45 12 45 32 5 6
输出
1 2