【华为机试在线训练】Day4

题目描述

开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。

输入：

合法坐标为A(或者D或者W或者S) + 数字（两位以内）

坐标之间以;分隔。

非法坐标点需要进行丢弃。如AA10;  A1A;  $%$;  YAD; 等。

下面是一个简单的例子 如：

A10;S20;W10;D30;X;A1A;B10A11;;A10;

处理过程：

起点（0,0）

+   A10   =  （-10,0）

+   S20   =  (-10,-20)

+   W10  =  (-10,-10)

+   D30  =  (20,-10)

+   x    =  无效

+   A1A   =  无效

+   B10A11   =  无效

+  一个空 不影响

+   A10  =  (10,-10)

结果 （10， -10）

输入描述:

一行字符串

输出描述:

最终坐标，以,分隔

#include<iostream>
#include<string>
#include<cstddef>   //std::size_t
using namespace std;
 
int main()
{
    string str;
    while(cin>>str){
        pair<int,int> point(0,0);               //point.first point.second
        size_t found = str.find_first_of(';');  //找到第一个';'的位置
        int start = 0;
 
        while(found!=string::npos){
            string s1 = str.substr(start,found-start);
            //cout << s1 << endl;
            start = found+1;
            found = str.find_first_of(';',found+1);
 
            if(s1.size()>1 && s1.size()<=3){    //合法的字符个数：2或3
                char c = s1[0];
                int n = 0;
                int invalid = 0;    //数字为是否非法
                for(int i=1; i<s1.size(); ++i){ //数字位判断与提取，A1A
                    if(s1[i]>='0'&&s1[i]<='9')
                        n = n*10 + (s1[i]-'0');
                    else{
                        invalid=1;
                        break;
                    }
                }
                if(invalid==0){
                    switch(c)
                    {
                        case 'A': {point.first-=n;break;}
                        case 'D': {point.first+=n;break;}
                        case 'W': {point.second+=n;break;}
                        case 'S': {point.second-=n;break;}
                    }
                }
 
            }
        }
        cout << point.first << ',' << point.second <<endl;
    }
    return 0;
}

---

---

题目描述

请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。

所有的IP地址划分为 A,B,C,D,E五类

A类地址1.0.0.0~126.255.255.255;

B类地址128.0.0.0~191.255.255.255;

C类地址192.0.0.0~223.255.255.255;

D类地址224.0.0.0~239.255.255.255；

E类地址240.0.0.0~255.255.255.255

私网IP范围是：

10.0.0.0～10.255.255.255

172.16.0.0～172.31.255.255

192.168.0.0～192.168.255.255

子网掩码为前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）

本题暂时默认以0开头的IP地址是合法的，比如0.1.1.2，是合法地址

输入描述:

多行字符串。每行一个IP地址和掩码，用~隔开。

输出描述:

统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。

懵逼状态

#include <stdlib.h>
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
using namespace std;
 
vector<string> split(string str, char del){
    stringstream ss(str);
    string tok;
    vector<string> ret;
    while(getline(ss, tok, del)){
        ret.push_back(tok);
    }
    return ret;
}
bool IPisvalid(vector<string> svec){
    if(svec.size() != 4){
        return false;
    }
    return true;
}
bool Maskisvalid(vector<string> svec){
    bool zero = false;
    if(svec.size() != 4){
        return false;
    }
    for(int i = 0; i < 4; i++){
        if(zero == false){
            if(atoi(svec[i].c_str()) != 255){
                if(atoi(svec[i].c_str()) != 0 &&
                   atoi(svec[i].c_str()) != 128 &&
                   atoi(svec[i].c_str()) != 192 &&
                   atoi(svec[i].c_str()) != 224 &&
                   atoi(svec[i].c_str()) != 240 &&
                   atoi(svec[i].c_str()) != 248 &&
                   atoi(svec[i].c_str()) != 252 &&
                   atoi(svec[i].c_str()) != 254){
                    return false;
                }else{
                    zero = true;
                }
            }
        }else{
            if(atoi(svec[i].c_str()) != 0){
                return false;
            }
        }
    }
    if(atoi(svec[3].c_str()) == 255){
        return false;
    }
    return true;
}
 
int main(){
    vector<int> ret(7, 0);
    string str;
    vector<string> svec;
    vector<string> ip;
    vector<string> mask;
    while(getline(cin, str)){
        svec = split(str, '~');
        ip = split(svec[0], '.');
        mask = split(svec[1], '.');
        if(Maskisvalid(mask) && IPisvalid(ip)){
            if (atoi(ip[0].c_str()) >= 1 && atoi(ip[0].c_str()) <= 126){
                ++ret[0];
                if (atoi(ip[0].c_str()) == 10)
                    ++ret[6];
            }else if (atoi(ip[0].c_str()) >= 128 && atoi(ip[0].c_str()) <= 191){
                ++ret[1];
                if (atoi(ip[0].c_str()) == 172){
                    if (atoi(ip[1].c_str()) >= 16 && atoi(ip[1].c_str()) <= 31)
                        ++ret[6];
                }
            }
            else if (atoi(ip[0].c_str()) >= 192 && atoi(ip[0].c_str()) <= 223){
                ++ret[2];
                if (atoi(ip[0].c_str()) == 168)
                    ++ret[6];
            }
            else if (atoi(ip[0].c_str()) >= 224 && atoi(ip[0].c_str()) <= 239){
                ++ret[3];
            }
            else if (atoi(ip[0].c_str()) >= 240 && atoi(ip[0].c_str()) <= 255){
                ++ret[4];
            }
        }else{
            ret[5]++;
        }
    }
    cout << ret[0] << " " << ret[1] << " " << ret[2] << " " << ret[3] << " " << ret[4] << " " << ret[5] << " "<< ret[6] << endl;
    return 0;
}

---

---

题目描述

计算最少出列多少位同学，使得剩下的同学排成合唱队形

说明：

N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。 
合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK，   则他们的身高满足存在i（1<=i<=K）使得T1<T2<......<Ti-1<Ti>Ti+1>......>TK。 
 你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

输入描述:

整数N

输出描述:

最少需要几位同学出列

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
 
// 基本思路，两遍最长递增子序列，并找和最大
/*
来说一下我的思路，两遍最长递增子序列，第一遍从左往右，第二遍从右往左，然后把两遍动态规划的结果相加，取最大的那个，比如8 186 186 150 200 160 130 197 200，第一遍dp的结果是 1 1 1 2 2 1 3 4，第二遍dp的结果为3 3 2 3 2 1 1 1，那么相加最大是5，所以需要出列的同学个数就是8-5+1=4.代码如下：
*/
int main(void)
{
    int n;
    while (cin >> n)
    {
        int tmp;
        vector<int> queue;
        vector<int> dp_1(n, 1);
        vector<int> dp_2(n, 1);
         
        for (int i = 0; i < n; ++i)
        {
            cin >> tmp;
            queue.push_back(tmp);
        }
 
        // 第一遍dp
        for (int i = 0; i < n; ++i)
        {
            for (int j = i - 1; j >= 0; --j)
            {
                if (queue[i] > queue[j] && dp_1[i] < dp_1[j] + 1)
                    dp_1[i] = dp_1[j] + 1;
            }
        }
 
        std::reverse(queue.begin(), queue.end());
        // 第二遍dp
        for (int i = 0; i < n; ++i)
        {
            for (int j = i - 1; j >= 0; --j)
            {
                if (queue[i] > queue[j] && dp_2[i] < dp_2[j] + 1)
                    dp_2[i] = dp_2[j] + 1;
            }
        }
        std::reverse(dp_2.begin(), dp_2.end());
 
        int max = -1;
        int sum;
        for (int i = 0; i < n; ++i)
        {
            sum = dp_1[i] + dp_2[i];
            if (sum > max)
            {
                max = sum;
            }
        }
        cout << n - max + 1 << endl;
    }
    return 0;
}