PAT 1112 Stucked Keyboard[比较]

1112 Stucked Keyboard（20 分）

On a broken keyboard, some of the keys are always stucked. So when you type some sentences, the characters corresponding to those keys will appear repeatedly on screen for k times.

Now given a resulting string on screen, you are supposed to list all the possible stucked keys, and the original string.

Notice that there might be some characters that are typed repeatedly. The stucked key will always repeat output for a fixed k times whenever it is pressed. For example, when k=3, from the string thiiis iiisss a teeeeeestwe know that the keys i and e might be stucked, but s is not even though it appears repeatedly sometimes. The original string could be this isss a teest.

Input Specification:

Each input file contains one test case. For each case, the 1st line gives a positive integer k (1<k≤100) which is the output repeating times of a stucked key. The 2nd line contains the resulting string on screen, which consists of no more than 1000 characters from {a-z}, {0-9} and _. It is guaranteed that the string is non-empty.

Output Specification:

For each test case, print in one line the possible stucked keys, in the order of being detected. Make sure that each key is printed once only. Then in the next line print the original string. It is guaranteed that there is at least one stucked key.

Sample Input:

3
caseee1__thiiis_iiisss_a_teeeeeest

Sample Output:

ei
case1__this_isss_a_teest

题目大意：给出一个数k和字符串，判断键是否坏了，如果一个字符联系出现K次超过2回，那么被判定为键坏了。输出的时候根据键的发现坏的先后顺序；

非常重要的一点就是：对于普通的按键来说，可能是多按了几次，但是坏的键一定是每按一次重复K次的！

所以比如这样的：

3
fffeee_fffeeeff   那么f一定不是坏的键！因为最后一个只出现了两次！！

这样的：

3
fffeee是f和e均是坏键！

//这个看似简单，写的时候出现了好多问题啊！最大的问题就是怎么按出现的先后顺序输出，如果用map的话，它会按关键字自动排序，使用了unorder_map也是给排序了，我都醉了。

事实证明，无序的map还是排序了：

set也排序的吗？？好吧。

//题的难点感觉是如何让这些点按出现的顺序输出，最终的数组里是无记忆的，并不能它们的顺序，

比如 3 eeefff_fffeee此时应该输出ef，而不是fe。

我已经放弃了。

#include <iostream>
#include <cmath>
#include <unordered_map>
#include <set>
using namespace std;
unordered_map<char,int> mp;
bool f[];
int main()
{
    int k;
    string ch;
    cin>>k;
    cin>>ch;
    int len=ch.size();
    set<char> st;
    vector<char> vt;
    for(int i=; i<len; i++)
    {
        bool flag=true;
        for(int j=i+; j<i+k&&ch[j]!='\0'; j++)
        {
            if(ch[i]!=ch[j])
            {
                flag=false;
                break;
            }
        }
        if(flag)
        {
            mp[ch[i]]++;
            int id;
            if(isdigit(ch[i]))id=ch[i]-'';
            else if(isalpha(ch[i])) id=ch[i]-'a'+;
            else id=;
            if(!f[id]){
                vt.push_back(ch[i]);//按照出现的顺序将其放入，那么这样就不能根据下标查找啊。
                f[id]=true;
            }
            //out<<i<<" "<<ch[i]<<'\n';
//            if(mp[ch[i]]>1&&st.find(ch[i])==st.end()){
//                cout<<ch[i];
//                st.insert(ch[i]);
//            }
            i+=(k-);
        }
    }
    //cout<<'\n';
    for(unordered_map<char,int>::iterator it=mp.begin(); it!=mp.end(); it++)
    {
        if(it->second>)
        {
           // cout<<it->second<<" ";
            //cout<<it->first;
            string str;
            int pos;
            for(int i=; i<k; i++)
                str+=it->first;
            while(ch.find(str)!=string::npos)
            {
                pos=ch.find(str);
                ch.erase(pos,k-);
            }
        }
    }
    cout<<'\n'<<ch;
    return ;
}
/***
3
feeeefe
3
eeeffffffeee
***/

//写成了这样 ，还是决定放弃，不知道怎么记录它们的顺序。

大佬代码：https://blog.csdn.net/kakitgogogo/article/details/52108461

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
using namespace std;

int main()
{
    int k;
    string s;
    cin>>k>>s;
    int n=s.size();
    bool isprob[];
    memset(isprob,true,sizeof(isprob));
    set<char>res;
    for(int i=;i<n;)//这里对i的操作没有写，下边是直接对i赋值，没有见过这样的，学习了。
    {
        int j=i+,count=,idx;
        if(isdigit(s[i])) idx=s[i]-'';
        else if(isalpha(s[i])) idx=s[i]-'a'+;
        else idx=;
        while(s[j]==s[i]&&j<n&&count<k)
        {
            count++;
            j++;
        }
        if(count==k&&isprob[idx])
        {
            res.insert(s[i]);
        }
        else if(count!=k)
        {
            isprob[idx]=false;
            //但是这个集合并没有表示所有的。
            //如
            res.erase(s[i]);///在集合中删除也是这样。
        }
        i=j;//不管是否是重复的那么i=j，这样就实现了对i的更新了。
    }

    set<char>res2=res;///可以直接赋值创建的。
    for(int i=;i<n;i++)
    {
        if(res2.find(s[i])!=res2.end())///原来是通过将集合中的不变，去从头遍历啊!

        {
            cout<<s[i];//这样是一定可以保证是按顺序来的。
            res2.erase(s[i]);
        }
        if(res2.empty()) break;
    }
    cout<<endl;
    for(int i=;i<n;)
    {
        if(res.find(s[i])!=res.end())///如果能找得到，那么就输出，简直太厉害了。
        {
            cout<<s[i];
            i+=k;
        }
        else
        {
            cout<<s[i];
            i++;
        }
    }
    cout<<endl;
}
/***
3
fffeee

***/

1.使用set来存，如果后来不相等，那么就从set中删除，并标记为false;

2.顺序的话是通过顺序遍历字符串得到的，遍历过一次就从set中删除；

3.其实这个id可以用map来表示的。