5.2练习

 找出字符串中第一个只出现一次的字符

找出字符串中第一个只出现一次的字符

数据范围：输入的字符串长度满足1≤n≤1000 

输入描述：

输入一个非空字符串

输出描述：

输出第一个只出现一次的字符，如果不存在输出-1

示例1

输入：

asdfasdfo

输出：

o

#include <iostream>
#include <unordered_map>
using namespace std;
int Find_char(string &s) {
    unordered_map<char, int> map;
    for (int i = 0; i < s.size(); i++) {
        map[s[i]]++;
    }
    for (int i = 0; i < s.size(); i++) 
    {
        if (map[s[i]] == 1) 
        {
           return i;
        }
    }
    return -1;
}
int main() {
    string s;
    while (cin>>s) 
    {
        int pos=Find_char(s);
        if(pos==-1)
            cout<<"-1"<<endl;
        else
            cout<<s[pos]<<endl;
    }
    return 0;
}

DNA 序列

一个 DNA 序列由 A/C/G/T 四个字母的排列组合组成。 G 和 C 的比例（定义为 GC-Ratio ）是序列中 G 和 C 两个字母的总的出现次数除以总的字母数目（也就是序列长度）。在基因工程中，这个比例非常重要。因为高的 GC-Ratio 可能是基因的起始点。

给定一个很长的 DNA 序列，以及限定的子串长度 N ，请帮助研究人员在给出的 DNA 序列中从左往右找出 GC-Ratio 最高且长度为 N 的第一个子串。

DNA序列为 ACGT 的子串有: ACG , CG , CGT 等等，但是没有 AGT ， CT 等等

数据范围：字符串长度满足 1≤n≤1000  ，输入的字符串只包含 A/C/G/T 字母

输入描述：

输入一个string型基因序列，和int型子串的长度

输出描述：

找出GC比例最高的子串,如果有多个则输出第一个的子串

示例1

输入：

ACGT
2

输出：

CG

说明：

ACGT长度为2的子串有AC,CG,GT3个，其中AC和GT2个的GC-Ratio都为0.5，CG为1，故输出CG   

#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;

int main() 
{
    string s;
    int n;
    while(cin>>s>>n)
    {
        int cnt=0;
        int MaxCnt=0;
        for(int i=0;i<n;i++)
        {
            if(s[i]=='C'||s[i]=='G')
                cnt++;
        }
        MaxCnt=cnt;
        int left=1,right=n;
        int index=0;
        while(right < s.size())
        {
            //缩小窗口
            if(s[left-1]=='C'|| s[left-1]=='G')
                cnt--;
            //增大窗口
            if(s[right]=='C'|| s[right]=='G')
                cnt++;   
            //更新返回字串的左边界
            if(cnt > MaxCnt)
            {
                MaxCnt=cnt;
                index=left;
            }
            left++;
            right++;
        }
        cout<<s.substr(index,n)<<endl;
        
    }
    return 0;
}

MP3光标位置

MP3 Player因为屏幕较小，显示歌曲列表的时候每屏只能显示几首歌曲，用户要通过上下键才能浏览所有的歌曲。为了简化处理，假设每屏只能显示4首歌曲，光标初始的位置为第1首歌。

现在要实现通过上下键控制光标移动来浏览歌曲列表，控制逻辑如下：

1. 歌曲总数<=4的时候，不需要翻页，只是挪动光标位置。

光标在第一首歌曲上时，按Up键光标挪到最后一首歌曲；光标在最后一首歌曲时，按Down键光标挪到第一首歌曲。

其他情况下用户按Up键，光标挪到上一首歌曲；用户按Down键，光标挪到下一首歌曲。

2. 歌曲总数大于4的时候（以一共有10首歌为例）：

特殊翻页：屏幕显示的是第一页（即显示第1 – 4首）时，光标在第一首歌曲上，用户按Up键后，屏幕要显示最后一页（即显示第7-10首歌），同时光标放到最后一首歌上。同样的，屏幕显示最后一页时，光标在最后一首歌曲上，用户按Down键，屏幕要显示第一页，光标挪到第一首歌上。

一般翻页：屏幕显示的不是第一页时，光标在当前屏幕显示的第一首歌曲时，用户按Up键后，屏幕从当前歌曲的上一首开始显示，光标也挪到上一首歌曲。光标当前屏幕的最后一首歌时的Down键处理也类似。

其他情况，不用翻页，只是挪动光标就行。

数据范围：命令长度1≤s≤100 ，歌曲数量1≤n≤150 

进阶：时间复杂度： O(n) ，空间复杂度： O(n) 

输入描述：

输入说明：
1 输入歌曲数量
2 输入命令 U或者D

输出描述：

输出说明
1 输出当前列表
2 输出当前选中歌曲

示例1

输入：

10
UUUU

输出：

7 8 9 10
7

普通做法：

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

int main() {
    int n;
    string s;
    while (cin >> n >> s) {
        int index = 1;
        vector<int> res;
        int first=1;//当前屏幕显示页的第一首歌曲的编号
        //不需要翻页
        if (n <= 4) 
        {
            for (char ch : s) {
                if (ch == 'U') {
                    if (index == 1)
                        index = n;
                    else
                        index = index - 1;
                } else if (ch == 'D') {
                    index = (index + 1) % n;
                }
            }
            for(int i=1;i<=n-1;i++)
                cout<<i<<' ';
            cout<<n<<endl<<index<<endl;
        } 
        //要翻页
        else 
        {
            for (char ch : s) 
            {
                if(index==1 && ch=='U')
                {
                    first=n-3;
                    index=n;
                }
                else if(index==n && ch=='D')
                {
                    first=1;
                    index=1;
                }
                else if(index==first && ch=='U')
                {
                    first--;
                    index--;
                }
                else if(index==first+3 && ch=='D')
                {
                    first++;
                    index++;
                }
                else if(ch=='U')
                    index--;
                else 
                    index++;
            }  
            for(int i=first;i<first+3;i++)
                cout<<i<<' ';
            cout<<first+3<<endl<<index<<endl;

        }
    }
    return 0;
}

改进：

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

int main() {
    int n;
    string s;
    while (cin >> n >> s) {
        int index = 1;
        vector<int> res;
        int first = 1; //当前屏幕显示页的第一首歌曲的编号
        int end = min(4, n); //当前屏幕显示页的最后一首首歌曲的编号
        for (char ch : s) {
            //获取当前显示歌曲的编号
            if (ch == 'U') {
                index = (index - 1 - 1 + n) % n + 1;
            } else if (ch == 'D') {
                index = index % n+1;
            }
            //更新窗口的起始位置
            if (index < first) {
                first = index;
                end = first + 3;
            } else if (index > end) {
                end = index;
                first = end - 3;
            }
        }
        //输出当前页面显示的编号
        for (int i = first; i <= end; i++)
            cout << i << ' ';
        cout << endl << index << endl;
    }

    return 0;
}

查找两个字符串a,b中的最长公共子串

查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。

注：子串的定义：将一个字符串删去前缀和后缀（也可以不删）形成的字符串。请和“子序列”的概念分开！

数据范围：字符串长度1≤length≤300 

进阶：时间复杂度：O(n3) ，空间复杂度：O(n) 

输入描述：

输入两个字符串

输出描述：

返回重复出现的字符

示例1

输入：

abcdefghijklmnop
abcsafjklmnopqrstuvw

输出：

jklmnop

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

int main(){
    string s1, s2;
    while(cin >> s1 >> s2){
        if(s1.length() > s2.length()) //使较小的字符串在前
            swap(s1, s2);
        vector<vector<int> > dp(s1.length() + 1, vector<int>(s2.length() + 1, 0)); 
        int max = 0, end = 0;
        for(int i = 1; i <= s1.length(); i++){
            for(int j = 1; j <= s2.length(); j++){
                if(s1[i - 1] == s2[j - 1]) //如果该两位相同
                    dp[i][j] = dp[i - 1][j - 1] + 1; //则增加长度
                else //否则
                    dp[i][j] = 0; //该位置为0
                if(dp[i][j] > max){ //更新最大长度
                    max = dp[i][j];
                    end = i - 1;
                }
            }
        }
        cout << s1.substr(end - max + 1, max) << endl; //输出最长子串
    }
    return 0;
}