[C++] 在OJ中读取各种输入办法

在 OJ 做题中，往往会遇到各种输入，而这并不是 OJ 题目的核心所在，但往往会卡我们很久，因此本文总结了 OJ 中可能的输入情况，尽可能减少在输入上所花费的时间。
参考：部分内容参考自 NJU C++ 课程 PPT

一. 逗号分隔数字的输入

/**
 * 处理1,2,3;1,1的输入
 * @return
 */
int main(){
    vector<int> children;
    vector<int> cookies;
    char c;
    string input;
    cin >> input;
    int start = 0;
    for (int i = 0; i < input.length(); ++i) {
        if(input.at(i) == ','){
            int num = 0;
            for (int j = start; j < i ; ++j) {
                num = num*10 + (input[j] - '0');
            }
            children.push_back(num);
            start = i + 1;
        } else if(input.at(i) == ';') {
            int num = 0;
            for (int j = start; j < i ; ++j) {
                num = num*10 + (input[j] - '0');
            }
            children.push_back(num);
            start = i + 1;
            break;
        }
    }
    for (int i = start; i <= input.length(); ++i) { // 必须要 <=，否则最后一个数字读不进去
        if( i == input.length() || input.at(i) == ','){// 等于长度要放前面，否则后面的at会越界，用前面的成立短路后面的
            int num = 0;
            for (int j = start; j < i ; ++j) {
                num = num*10 + (input[j] - '0');
            }
            cookies.push_back(num);
            start = i + 1;
        }
    }

二. 读入未知数量的数字/字符/字符串，用空格分开

cin >> x 会跳过中间的所有空格和换行等空白字符

注意在 OJ 中的输入结束后是 EOF，所以 while 循环中会读到 EOF，从而终止。

但在 IDE 测试中键入 enter 是输入了 \n，cin跳过了 \n还在等待，所以不会终止，可以通过 ctrl+D 来终止

对于未知数量的数字，可以用 vector 的 pushback。

如果不能使用 vector，可以定义一个很大的数组，内存不是问题，一般可以直接int nums[10000];

//读入12345
int i;
while(cin>>i){}

//读入abcde
char c;
while(cin>>c){}

//读入abcdefghi
string s;
while(cin>>s){}

三. 需要读入空格等空白字符，需要一个一个字符的读取

char c;
while (cin.get(c)){}

可以持续读入字符，直到 EOF 终止，一般可以通过判断 c 是否为 \n 或其他字符来终止读取

四. 直接读取一整行数据

string s;
getline(cin, s);

• 通过 getline 可以把一整行读取到字符串中，用于后续处理

string s;
cin >> s;

• 如果一整行数据是没有空格或其他空白字符的，如一的情况，那么可以直接用 cin >> s 读取一行字符串

五. 模拟某某机的题目中 读取命令+参数

char instr[12];
int para;
scanf("%s %d",instr,&para);

• 使用格式化字符串输入，读取字符串的命令和整型参数【注意一定必须是 char[] 而不能是 string，后者无法通过 scanf 读入】

//使用char[]
char instr[12];
while(cin >> instr){
    if(strcmp(instr,"get") == 0){// strcmp需要引入 <cstring>	
        // 且两个字符串相等strcmp返回0
       	int para;
        cin >> para;
    }
    //或者如果禁止cstring
    if(instr[0] == 'g' && instr[1] == 'e' && instr[2] == 't'){
       	int para;
        cin >> para;
    }
    ...
}
//使用string
string instr;
while(cin >> s){
    if(s == "get")// 字符串string可以直接通过 < <= == !=进行比较，两者相等返回1
        ...
    ...
}

• 先通过 cin 读取命令，然后再根据命令的值来读取后面的参数【推荐】

六. 读取矩阵

int row,col;
cin >> row >> col;
//1.静态二维数组
int mat1[10][10];
//2.动态二维数组1
int **mat2 = new int*[10];//定义指针数组，此时mat2的类型为int **
for(int i = 0; i < 10; i++){//让指针数组中的每个指针指向一个一维动态数组
    mat2[i] = new int[10];
}
//3.动态二维数组2
int *p = new int[100];//定义一个一维动态数组
int (*mat3)[10] = (int(*)[10])p;//将一维动态数组升到二维，此时mat3的类型为int[10] *，即mat3[0]是一个指向一维数组的指针
//4.vector
vector<vector<int>> mat4;

for(int i = 0; i < row; i++){
    for(int j = 0; j < col; j++){
        cin >> mat[i][j];
    }
}

七. 读取图

• 使用 vector 【推荐】

void make_adjVertices(vector<vector<int>>& adjVertices, int v_num, int e_num){//生成邻接表
    int v1,v2;
    for (int i = 0; i < e_num; ++i) {
        cin >> v1 >> v2;// 视输入情况调整，这里表示v1有到v2的边
        adjVertices[v1].push_back(v2);
    }
}
void make_graph(){
    int v_num,e_num;
    cin >> v_num >> e_num;
    vector<vector<int>> adjVertices(v_num+1);//因为adjVertices中的下标表示顶点，[1]表示顶点1的邻接表，因此如果从1开始，需要是v_num+1，如果顶点0开始，则直接v_num
    make_adjVertices(adjVertices, v_num, e_num);
}

• 使用自定义的 node 节点

struct Node{//邻接表中的节点
    int v;
    Node *next = nullptr;
};
Node* add_edge(Node * p, int v){
    Node *vertex = new Node;
    vertex->v = v;
    vertex->next = nullptr;
    Node *prev = p;
    Node *curr = p->next;//p一定不为空，因为有dummy节点
    while(curr != nullptr){
        prev = curr;
        curr = curr->next;
    }
    prev->next = vertex;
}
Node **make_adjVertices(int v_num, int e_num){
    Node **adjVertices = new Node*[v_num+1];// 从1开始，下标表示顶点
    for (int i = 0; i < v_num+1; ++i) {// 定义一个dummy节点，可以很大程度方便后续的添加操作不用判断nullptr，而且dummy节点可以用来存储如size等信息，如果不用dummy节点，那么在初始时adjVertices[i]将是null，那么在传入adjVertices[i]到add_edge中时，会传入nullptr
        Node *p = new Node;
        p->v = 0;
        p->next = nullptr;
        adjVertices[i] = p;
    }
    int v1,v2;
    for (int i = 0; i < e_num; ++i) {
        cin >> v1 >> v2;
        add_edge(adjVertices[v1], v2);
    }
    return adjVertices;
}
int main(){
    int v_num,e_num;
    cin >> v_num >> e_num;
    Node **adjVertices = make_adjVertices(v_num, e_num);
}
//因为存在dummy节点，在访问邻接表时应当 p = adjVertices[w]->next;