ccf-201709-3 JSON查询（详解）

ccf-201709-3 JSON查询（详解）

---

试题编号： 201709-3

---

试题名称： JSON查询

---

时间限制： 1.0s

---

内存限制： 256.0MB

---

问题描述：

问题描述

　　JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，可以用来描述半结构化的数据。JSON 格式中的基本单元是值 (value)，出于简化的目的本题只涉及 2 种类型的值：
　　* 字符串 (string)：字符串是由双引号 ” 括起来的一组字符（可以为空）。如果字符串的内容中出现双引号 “，在双引号前面加反斜杠，也就是用 \” 表示；如果出现反斜杠 \，则用两个反斜杠 \ 表示。反斜杠后面不能出现 ” 和 \ 以外的字符。例如：”“、”hello”、”\”\”。
　　* 对象 (object)：对象是一组键值对的无序集合（可以为空）。键值对表示对象的属性，键是属性名，值是属性的内容。对象以左花括号 { 开始，右花括号 } 结束，键值对之间以逗号 , 分隔。一个键值对的键和值之间以冒号 : 分隔。键必须是字符串，同一个对象所有键值对的键必须两两都不相同；值可以是字符串，也可以是另一个对象。例如：{}、{“foo”: “bar”}、{“Mon”: “weekday”, “Tue”: “weekday”, “Sun”: “weekend”}。
　　除了字符串内部的位置，其他位置都可以插入一个或多个空格使得 JSON 的呈现更加美观，也可以在一些地方换行，不会影响所表示的数据内容。例如，上面举例的最后一个 JSON 数据也可以写成如下形式。
　　{
　　“Mon”: “weekday”,
　　“Tue”: “weekday”,
　　“Sun”: “weekend”
　　}
　　给出一个 JSON 格式描述的数据，以及若干查询，编程返回这些查询的结果。
输入格式
　　第一行是两个正整数 n 和 m，分别表示 JSON 数据的行数和查询的个数。
　　接下来 n 行，描述一个 JSON 数据，保证输入是一个合法的 JSON 对象。
　　接下来 m 行，每行描述一个查询。给出要查询的属性名，要求返回对应属性的内容。需要支持多层查询，各层的属性名之间用小数点 . 连接。保证查询的格式都是合法的。

输出格式

　　对于输入的每一个查询，按顺序输出查询结果，每个结果占一行。
　　如果查询结果是一个字符串，则输出 STRING ，其中 是字符串的值，中间用一个空格分隔。
　　如果查询结果是一个对象，则输出 OBJECT，不需要输出对象的内容。
　　如果查询结果不存在，则输出 NOTEXIST。

样例输入

10 5
{
“firstName”: “John”,
“lastName”: “Smith”,
“address”: {
“streetAddress”: “2ndStreet”,
“city”: “NewYork”,
“state”: “NY”
},
“esc\aped”: “\”hello\””
}
firstName
address
address.city
address.postal
esc\aped

样例输出

STRING John
OBJECT
STRING NewYork
NOTEXIST
STRING “hello”

评测用例规模与约定

　　n ≤ 100，每行不超过 80 个字符。
　　m ≤ 100，每个查询的长度不超过 80 个字符。
　　字符串中的字符均为 ASCII 码 33-126 的可打印字符，不会出现空格。所有字符串都不是空串。
　　所有作为键的字符串不会包含小数点 .。查询时键的大小写敏感。
　　50%的评测用例输入的对象只有 1 层结构，80%的评测用例输入的对象结构层数不超过 2 层。举例来说，{“a”: “b”} 是一层结构的对象，{“a”: {“b”: “c”}} 是二层结构的对象，以此类推。

---

思路解析

关键词分析

思路解析

1、json对象的属性一般都是字符串，map比较方便，所以用map<string,string>来储存json对象的属性和值
2、虽然json对象可以内嵌，但没有关系，在键值上区分即可，形如查询样式："a.b.c":"b" 和"a":"b"
3、将一整个json对象存进一个字符串中,并去除空格与反斜杠和引号前的反斜杠，截取属性时，对一个字符串处理即可
4、截取key，对应属性，key有此规律："<内容>"：，不管内容怎样，只要找到第一个引号，再找到第一个冒号就可以了（假设内容里没有","、"{}"、":",当然事实证明ccf测试样例里面真的没有）
5、截取value，对应值，value由此规律：{<内容>} 或 "<内容>"，，不管内容怎样，只要找到第一个引号或花括号，再找到第一个逗号或者对应的花括号（花括号可以用类似栈的原理）就可以了（假设同上）
遇到值是对象的，用处理函数递归再处理一遍，处理完一条属性和值存进map中
7、查询语句直接查询map中是否存在
8、输出结果
代码版本2.0

---

code

版本1.0

这个是我最初想的思路，本来觉得挺清晰的、挺简单的，但是真正开始做的时候我发现不是那么回事！大体方向不好，细节也很欠缺！

原始思路

1、json对象的属性一般都是字符串，map比较方便，所以用map<string,string>来储存一个json对象的属性和值
2、考虑到json对象可以内嵌，所以用vector，可以把第一层的属性放到vector[0]中，内嵌的json对象放到vector[1]、vector[2]。。。中，只要在对应的属性值处记好序号就行（可优化）
3、将一整个json对象存进一个字符串中，截取属性时，对一个字符串处理即可（可优化）
4、截取key，对应属性，key有此规律："<内容>"，内容可能包含'\' → '\\'、'"' → '\"' 只要找到第一个引号，再找到前面不是反斜杠的引号就可以了（有重大bug）
5、截取value，对应值，value由此规律：{<内容>} 或 "<内容>"，内容可能包含'\' → '\\'、'"' → '\"'，找到第一个引号或花括号，再找到前面不是反斜杠的引号或者对应的花括号（花括号可以用类似栈的原理代码如下）就可以了（有重大bug）

<c++>
while(!kh.empty())
    kh.pop();
kh.push(a[q2]);
while(!kh.empty()) {
    q1=a.find_first_of("{}",q2+1);
    if(kh.top()==a[q1]) {
        kh.push(a[q1]);
    } else {
        kh.pop();
    }
    q2=q1;
}
或者
v0=1;
v1=k1+2;
while(v0>0) {
    if(a[v1]=='{') {
        v0++;
    } else if(a[v1]=='}') {
        v0--;
    }
    v1++;
}
</c++>

6、遇到值是对象的，用处理函数递归再处理一遍，处理完一个json对象存进vector中（可优化）
7、将查询语句按照“.”切割，递归的查询map中是否存在（可优化）
8、输出结果
以上 ”可优化“ 查看思路解析，”有重大bug“ 查看易错分析

#include <iostream>
#include <string>
#include <map>
#include <sstream>
#include <vector>
#include <stack>
using namespace std;

string json="",temp;
vector< map<string,string> > objs;
stack<char> kh;
int n,q;

string int2str(int a) {
    stringstream ss;
    ss << a;
    return ss.str();
}
int str2int(string a) {
    int b;
    stringstream ss;
    ss << a;
    ss >> b;
    return b;
}
//辅助函数

void rm(string &a) {
    string a0=a;
    int p0;
    p0=a.find("\\");
    while(p0>-1) {
        a.erase(p0,1);
        p0=a.find("\\",p0+1);
    }
}//删除'\\'、'\"'

void splitJson(string a) {
    map<string,string> obj;
    string key,value;
    a.erase(0,1);
    a.erase(a.size()-1,1);

    int p0,p1,q0,q1;
    p0=a.find('"');
    while(p0>-1) {
        p1=a.find(':',p0+1);
        key=a.substr(p0+1,p1-p0-2);
        //截取key

        p0=a.find('"',p1+1);
        q0=a.find_first_of("{}",p1+1);
        if(q0<p0&&q0>-1) {//值是json对象
            int q2=q0;;
            while(!kh.empty())
                kh.pop();
            kh.push(a[q2]);
            while(!kh.empty()) {
                q1=a.find_first_of("{}",q2+1);
                if(kh.top()==a[q1]) {
                    kh.push(a[q1]);
                } else {
                    kh.pop();
                }
                q2=q1;
            }
            temp=a.substr(q0,q1-q0+1);

            splitJson(temp);
            value="{"+int2str(objs.size()-1);
            p1=q1;
        } else {//值是字符串
            p1=a.find(',',p0+1);
            if(p1==-1) {
                p1=a.size();
            }
            value=a.substr(p0+1,p1-p0-2);
        }

        obj[key]=value;
        p0=a.find('"',p1+1);
    }
    objs.push_back(obj);
}
void find(string a,int i) {
    int p0;
    string query;
    p0=a.find('.');
    if(p0>-1) {
        query=a.substr(0,p0);
        a.erase(0,p0+1);
    } else {
        query=a;
        a="";
    }
    if(objs[i].count(query)) {//key存在
        if(a.size()==0) {
            if(objs[i][query][0]=='{') {
                cout<<"OBJECT"<<endl;
            } else {
                cout<<"STRING "<<objs[i][query]<<endl;
            }
        } else {
            if(objs[i][query][0]=='{') {
                query=objs[i][query].substr(1,objs[i][query].size()-1);
                find(a,str2int(query));
            } else {
                cout<<"NOTEXIST"<<endl;
            }
        }
    } else {
        cout<<"NOTEXIST"<<endl;
    }
}

int main() {
    cin>>n>>q;
    getline(cin,temp);
    for(int i=0; i<n; i++) {
        getline(cin,temp);
        int p0;
        p0=temp.find(' ');
        while(p0>-1) {
            temp.erase(p0,1);
            p0=temp.find(' ',p0);
        }
        json+=temp;
    }
    rm(json);
    splitJson(json);
    for(int i=0; i<q; i++) {
        cin>>temp;
        find(temp,objs.size()-1);
    }
    return 0;
}

版本2.0

#include <iostream>
#include <string>
#include <map>
using namespace std;
string json0,temp;
map<string,string> obj;
int n,q;
void rm(string &a) {
    int p0=a.find_first_of(" \\");
    while(p0>-1) {
        a.erase(p0,1);
        p0 += a[p0]=='"'||a[p0]=='\\'? 1 : 0;
        p0=a.find_first_of(" \\",p0);
    }
}
void splitJson(string a,string b) {
    string json;
    int k0=a.find('"');
    while(k0>-1) {
        int k1=a.find(':',k0+1);
        json = a.substr(k0+1,k1-k0-2);
        json = b.size()? b+"."+json : b+json;
        int v0,v1;
        if(a[k1+1]=='"') {
            v0=k1+1;
            v1=a.find(',',v0+1);
            if(v1==-1) {
                v1=a.size()-1;
            }
            temp=a.substr(v0+1,v1-v0-2);
            temp="STRING "+temp;
        } else {
            v0=1;
            v1=k1+2;
            while(v0>0) {
                if(a[v1]=='{') {
                    v0++;
                } else if(a[v1]=='}') {
                    v0--;
                }
                v1++;
            }
            temp=a.substr(k1+1,v1-k1-1);
            splitJson(temp,json);
            temp="OBJECT";
        }
        obj[json]=temp;
        k0=a.find('"',v1);
    }
}
int main() {
    cin>>n>>q;
    getline(cin,temp);
    for(int i=0; i<n; i++) {
        getline(cin,temp);
        rm(temp);
        json0+=temp;
    }
    splitJson(json0,"");
    for(int i=0; i<q; i++) {
        cin>>temp;
        if(obj.count(temp)) {
            cout<<obj[temp]<<endl;
        } else {
            cout<<"NOTEXIST"<<endl;
        }
    }
    return 0;
}

---

问题剖析

易错点

1、

如果字符串的内容中出现双引号 “，在双引号前面加反斜杠，也就是用 \” 表示；如果出现反斜杠 \，则用两个反斜杠 \ 表示。反斜杠后面不能出现 ” 和 \ 以外的字符。例如：”“、”hello”、”\”\”

这里就是一个坑，如果按照版本1.0里的思路去写，根本不能避免。
我虽然想到了这种情况："asd\\asd\"dsd" 但这根本不够，还有这种"asd\\"（2018年9月10日：这种测试样例大约有10%）

2、

如果查询结果不存在，则输出 NOTEXIST

这是我的思路原因，之前我一直认为查询的深度不会超过内嵌层数，导致我判断不存在的深度只到所给json的内嵌层数！

测试样例

以上两种情况的测试样例如下：

12 2
{
“\\”ggg\”:”\\”hhh”,
“iii\”:{
“\”:”jjj”,
{
“kkk”:{
“lll”:”\”\”\”
}
}
}
}