hihocoder 1485----hiho字符串

hihocoder 1485:hiho字符串

描述

如果一个字符串恰好包含2个'h'、1个'i'和1个'o'，我们就称这个字符串是hiho字符串。  

例如"oihateher"、"hugeinputhugeoutput"都是hiho字符串。

现在给定一个只包含小写字母的字符串S，小Hi想知道S的所有子串中，最短的hiho字符串是哪个。

输入

字符串S  

对于80%的数据，S的长度不超过1000  

对于100%的数据，S的长度不超过100000

输出

找到S的所有子串中，最短的hiho字符串是哪个，输出该子串的长度。如果S的子串中没有hiho字符串，输出-1。

样例输入

happyhahaiohell

样例输出

5

算法分析：

声明一个 char str[100001] 字符数组，用 cin.getline(str,100001) 来获取每一行的输入字符串。声明 char* ph1,*ph2,*pi,*po 指针，并初始化为0，用来记录 str 字符串中 h、i、o 字符出现的位置。当出现 i 字符时，要判断前面是否出现过 i 字符，如果出现过（用 if(pi!=0) 来判断），则在 前一个 i 出现的位置之前出现的 h 和 o 都要被舍弃掉了（因为我们要找的字符串中只能有2个 h，1个 i ，1个 o）；同样的道理适用于字符 o。对于字符 h ，情况略微不同。当出现字符 h 时，要判断 if(ph1!=0)，如果为真，则在 h1 之前出现的 i 和 o 都要舍弃掉。 每当 h1,h2,i,o 都齐备的时候，我们就统计一下当前选取的字段的长度，如果小于已经记录的长度，则更新已经记录的长度。最后判断记录的长度值是否为初始化时设置的最大值(least=0X7FFFFFFF)：如果是，说明str中没有hiho字符串，返回-1；否则返回记录的长度值。

C++算法实现：

#include<iostream>
using namespace std;

char* ph1 = 0, *ph2 = 0, *pi = 0, *po = 0;

int getCount(char str[]);   
int getLen();

int main(int argc, char* argv[])
{
    char str[100001];
    while (cin.getline(str, 100001)) {
        cout << getCount(str) << endl;
    }
    return 0;
}

int getCount(char str[])
{
    char* cur = str;
    ph1 = ph2 = pi = po = 0;
    int least = 0x7FFFFFFF;
    int tmp = 0x7FFFFFFF;
    int occur = 0;//遇到了 'h','i','o'中的任何一个
    while (*cur != '\0') {
        occur = 1;
        switch (*cur) {
        case 'h':
            if (ph1 != 0) {
                //在前一个 h 之前出现的 i 和 o 都不可用了
                if (pi < ph1) {
                    pi = 0;
                    occur = 0;
                }
                if (po < ph1) {
                    ph1 = 0;
                    occur = 0;
                }
            }
            ph1 = ph2;
            ph2 = cur;
            break;
        case 'i':
            if (pi != 0) {
                //在前一个 i 之前出现的 h 和 o 都不可用了
                if (ph1 < pi) {
                    ph1 = 0;
                    occur = 0;
                }
                if (ph2 < pi) {
                    ph2 = 0;
                }
                if (po < pi) {
                    po = 0;
                    occur = 0;
                }
            }
            pi = cur;
            break;
        case 'o':
            if (po != 0) {
                //在前一个 o 之前出现的 h 和 i 都不可用了
                if (ph1 < po) {
                    ph1 = 0;
                    occur = 0;
                }
                if (ph2 < po) {
                    ph2 = 0;
                }
                if (pi < po) {
                    pi = 0;
                    occur = 0;
                }
            }
            po = cur;
            break;
        default:
            occur = 0;//没有发生有效变化
            break;
        }
        if (occur) {//发生了有效变化
            tmp = getLen();
            if (tmp < least) {
                least = tmp;
            }
        }
        cur++;
    }
    if (least == 0x7FFFFFFF) {//没有 hiho 字符串出现
        return -1;
    }
    return least;
}

int getLen()
{
    if (ph1 != 0 && pi != 0 && po != 0) {
        char* begin = ph1 < pi ? ph1 : pi;
        char* end = ph2 < pi ? pi : ph2;
        begin = begin < po ? begin : po;
        end = end < po ? po : end;
        return end - begin + 1;
    }
    return 0x7FFFFFFF;
}

转载于:https://www.cnblogs.com/dongling/p/6626128.html