笔试DAY3

字符串排序

题目描述：
月神拿到一个新的数据集，其中每个样本都是一个字符串（长度小于100），样本的的后六位是纯数字，月神需要将所有样本的后六位数字提出来，转换成数字，并排序输出。月神要实现这样一个很简单的功能确没有时间，作为好朋友的你，一定能解决月神的烦恼，对吧。
输入描述:
每个测试用例的第一行是一个正整数M（1<=M<=100)，表示数据集的样本数目。接下来输入M行，每行是数据集的一个样本，每个样本均是字符串，且后六位是数字字符。
输出描述:
对每个数据集，输出所有样本的后六位构成的数字排序后的结果（每行输出一个样本的结果）

#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;

bool cmp(int a,int b){
    return a < b;
}
int main(){
    int m;
    vector<int> s;
    string temp;
    int temp2;
    cin>>m;
    while(m){
        cin>>temp;
        temp.erase(temp.begin(),temp.end()-6);//****
        //temp:string=>int
        temp2 = atoi(temp.c_str());//****
        s.push_back(temp2);
        m--;
    }
    sort(s.begin(),s.end(),cmp);//****
    for(int i=0;i<s.size();i++){
        if( i<= s.size()-2){
            cout<<s[i]<<endl;
        }
        else{
            cout<<s[i];
        }
    }
    return 0;
}

回文字符串

题目描述：
最大回文子串是被研究得比较多的一个经典问题。最近月神想到了一个变种，对于一个字符串，如果不要求子串连续，那么一个字符串的最大回文子串的最大长度是多少呢。
输入描述:
每个测试用例输入一行字符串（由数字0-9，字母a-z、A-Z构成），字条串长度大于0且不大于1000.
输出描述:
输出该字符串的最长回文子串的长度。（不要求输出最长回文串，并且子串不要求连续）

说明：因为在本题中，不要求回文子串连续，故最长回文子串为aba(或ada、aca)
备注：因为不要求子串连续，所以字符串abc的子串有a、b、c、ab、ac、bc、abc7个

#include <iostream>
#include<bits/stdc++.h>
#define N 1000
using namespace std;
//可以使用递归的算法，但是这种算法对于字符串较大的情况会通不过，但是思路很简单
int dp(char*s,int start, int end){
    if (start>end){
        return 0;
    }else if(start==end){
        return 1;
    }else{
        if(s[start]==s[end]){
            return dp(s,start+1,end-1)+2;
        }else{
            return max(dp(s,start+1,end),dp(s,start,end-1));
        }
    }
}
 
//使用动态规划的思想，d[i][j]表示字符串s中位置j到位置i（i>j）的字符串中的最长的回文长度，
//当s[i]==s[j]时,d[i][j]的最长回文字符串长度为其子串d[i-1][j+1]的长度+2
//当s[i]!=s[j]时,d[i][j]的最长回文字符串长度为d[i-1][j]和d[i][j+1]两个中的最大值
//最后，d[n-1][0]就是最后的长度
int dp(char*s){
    int n =strlen(s);
    int i,j;
    int d[N][N];
    for(i=0;i<n;i++){
        d[i][i]=1;
        for(j=i-1;j>-1;j--){
            if(s[i]==s[j]){
                d[i][j]=d[i-1][j+1]+2;
            }else{
                d[i][j]=max(d[i-1][j],d[i][j+1]);
            }
        }
    }
    return d[n-1][0];
}
int main(){
    char s[1000];
    cin>>s;
    cout<<dp(s)<<endl;
}

def max_sub_str_length(raw_str):
    dp = {}
    def length_from_l_to_r(l, r):
        if l == r:
            return 1
        if l > r:
            return 0
        if (l, r) in dp:
            return dp[(l, r)]
        sub_str_length = 0
        if raw_str[l] == raw_str[r]:
            sub_str_length = 2 + length_from_l_to_r(l+1, r-1)
        else:
            sub_str_length = max(length_from_l_to_r(l+1, r), length_from_l_to_r(l, r-1))
        dp[(l, r)] = sub_str_length
        return sub_str_length
    return length_from_l_to_r(0, len(raw_str)-1)
 
 
raw_str = input()
print(max_sub_str_length(raw_str))

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
/**
 * 求最长回文子串的问题，一般有两种方法
 * 1.动态规划
 * 2.中心扩散方法
 */
public class Solution8_回文字符串 {
 
    /**
     * 最长文回串 ，非连续
     * 动态规划
     */
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String s = bf.readLine();
        int n = s.length();
        int[][] dp = new int[n][n];//dp[l][r]表示l-r中的最长回文串
        for (int r = 0; r < n; r++) {
            dp[r][r] = 1;
            for (int l = r - 1; l >= 0; l--) {
                if (s.charAt(l) == s.charAt(r)) {
                    dp[l][r] = dp[l + 1][r - 1] + 2;
                }else {
                    dp[l][r] = Math.max(dp[l+1][r],dp[l][r-1]);
                }
            }
        }
        System.out.println(dp[0][n-1]);
    }
}

既然刷到了这个题，还是要介绍一下最原始的求解最长回文子串的问题，即回文串是连续的。

public class Solution144_5_最长回文子串 {
 
    /**
     * 方法一：中心扩展法
     * 1.既然是回文字符串，本来联想的是滑动窗口，双指针这样的思想，发现并不行，
     * 无法确保 abcd...这一段是否是回文串，万一继续后面是dcba，总不能全部遍历吧，那就等于暴力算法了。
     * 2.回文串的特点，由中间到两边扩散，aba 或者 bb这样的形式，这就需要我们分情况讨论了。
     * for循环以每一个点为中心，求最长文回串，从中心点向两边延伸，记录最长子串
     */
 
    private int start, maxLen;
 
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 2) return s;
        for (int i = 0; i < s.length(); i++) {
            //考虑两种情况1:aba  和 2: bb
            findMaxPalindrome(s, i, i);
            findMaxPalindrome(s, i, i + 1);
        }
        return s.substring(start, start + maxLen);
    }
 
    private void findMaxPalindrome(String s, int i, int j) {
        while (i >= 0 && j < s.length() && s.charAt(i) == s.charAt(j)) {
            i--;//向左延伸
            j++;//向右延伸
        }
        //记录每个起始点扩展的回文串的最大长度
        if (maxLen < j - i - 1) {
            start = i + 1;
            maxLen = j - i - 1;
        }
    }
 
    /**
     * 方法二：动态规划
     * 求解 "最优子结构" 问题，可以考虑用 "动态规划"
     */
    public String longestPalindrome1(String s) {
        int n = s.length();
        if (n < 2) return s;
        int maxLen = 1;
        String res = s.substring(0, 1);
        boolean[][] dp = new boolean[n][n];
        //左边界一定小于右边界，因此从右边界开始
        for (int r = 1; r < n; r++) { //表示右边界
            for (int l = 0; l < r; l++) { //表示左边界
                // 区间应该慢慢放大
                // 状态转移方程：如果头尾字符相等并且中间也是回文
                // 在头尾字符相等的前提下，如果收缩以后不构成区间（最多只有 1 个元素），直接返回 True 即可
                // 否则要继续看收缩以后的区间的回文性
                if (s.charAt(l) == s.charAt(r) && ((r - l) <= 2 || dp[l + 1][r - 1])) {
                    dp[l][r] = true;
                    if (r - l + 1 > maxLen) {
                        maxLen = r - l + 1;
                        res = s.substring(l, r + 1);
                    }
                }
            }
        }
        return res;
    }
}