#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <set>

using namespace std;

// 初始化亲属关系映射（路径→称谓）
map<string, string> initRelationMap() {
    map<string, string> relationMap;

    // ===================== 1. 直系亲属 =====================
    relationMap["父亲"] = "爸爸";
    relationMap["母亲"] = "妈妈";
    relationMap["儿子"] = "女儿";
    relationMap["女儿"] = "女儿";
    relationMap["爷爷"] = "祖父（父亲的父亲）";
    relationMap["奶奶"] = "祖母（父亲的母亲）";
    relationMap["外公"] = "外祖父（母亲的父亲）";
    relationMap["外婆"] = "外祖母（母亲的母亲）";
    relationMap["曾祖父"] = "曾祖父（爷爷的父亲）";
    relationMap["曾祖母"] = "曾祖母（爷爷的母亲）";
    relationMap["外曾祖父"] = "外曾祖父（外公的父亲）";
    relationMap["外曾祖母"] = "外曾祖母（外公的母亲）";
    relationMap["孙子"] = "孙子（儿子的儿子）";
    relationMap["孙女"] = "孙女（儿子的女儿）";
    relationMap["外孙"] = "外孙（女儿的儿子）";
    relationMap["外孙女"] = "外孙女（女儿的女儿）";

    // ===================== 2. 父系旁系（区分长幼） =====================
    relationMap["父亲的哥哥"] = "伯伯";
    relationMap["父亲的弟弟"] = "叔叔";
    relationMap["父亲的姐姐"] = "大姑";
    relationMap["父亲的妹妹"] = "小姑/姑姑";
    relationMap["父亲的哥哥的妻子"] = "伯母/大妈";
    relationMap["父亲的弟弟的妻子"] = "婶婶/婶娘";
    relationMap["父亲的姐姐的丈夫"] = "姑父/大姑父";
    relationMap["父亲的妹妹的丈夫"] = "姑父/小姑父";
    relationMap["父亲的哥哥的儿子"] = "堂哥（年长）/堂弟（年幼）";
    relationMap["父亲的哥哥的女儿"] = "堂姐（年长）/堂妹（年幼）";
    relationMap["父亲的弟弟的儿子"] = "堂哥（年长）/堂弟（年幼）";
    relationMap["父亲的弟弟的女儿"] = "堂姐（年长）/堂妹（年幼）";
    relationMap["父亲的姐姐的儿子"] = "表哥（年长）/表弟（年幼）";
    relationMap["父亲的姐姐的女儿"] = "表姐（年长）/表妹（年幼）";
    relationMap["父亲的妹妹的儿子"] = "表哥（年长）/表弟（年幼）";
    relationMap["父亲的妹妹的女儿"] = "表姐（年长）/表妹（年幼）";

    // ===================== 3. 母系旁系（区分长幼） =====================
    relationMap["母亲的哥哥"] = "大舅";
    relationMap["母亲的弟弟"] = "小舅/舅舅";
    relationMap["母亲的姐姐"] = "大姨/姨妈";
    relationMap["母亲的妹妹"] = "小姨/阿姨";
    relationMap["母亲的哥哥的妻子"] = "舅妈/大舅母";
    relationMap["母亲的弟弟的妻子"] = "舅妈/小舅母";
    relationMap["母亲的姐姐的丈夫"] = "姨父/大姨父";
    relationMap["母亲的妹妹的丈夫"] = "姨父/小姨父";
    relationMap["母亲的哥哥的儿子"] = "表哥（年长）/表弟（年幼）";
    relationMap["母亲的哥哥的女儿"] = "表姐（年长）/表妹（年幼）";
    relationMap["母亲的弟弟的儿子"] = "表哥（年长）/表弟（年幼）";
    relationMap["母亲的弟弟的女儿"] = "表姐（年长）/表妹（年幼）";
    relationMap["母亲的姐姐的儿子"] = "表哥（年长）/表弟（年幼）";
    relationMap["母亲的姐姐的女儿"] = "表姐（年长）/表妹（年幼）";
    relationMap["母亲的妹妹的儿子"] = "表哥（年长）/表弟（年幼）";
    relationMap["母亲的妹妹的女儿"] = "表姐（年长）/表妹（年幼）";

    // ===================== 4. 平辈亲属（区分长幼） =====================
    relationMap["哥哥"] = "哥哥（年长于自己的男性平辈）";
    relationMap["弟弟"] = "弟弟（年幼于自己的男性平辈）";
    relationMap["姐姐"] = "姐姐（年长于自己的女性平辈）";
    relationMap["妹妹"] = "妹妹（年幼于自己的女性平辈）";
    relationMap["哥哥的妻子"] = "嫂子";
    relationMap["弟弟的妻子"] = "弟妹/弟媳";
    relationMap["姐姐的丈夫"] = "姐夫";
    relationMap["妹妹的丈夫"] = "妹夫/妹婿";

    // ===================== 5. 配偶亲属 =====================
    relationMap["丈夫"] = "老公";
    relationMap["妻子"] = "老婆";
    relationMap["丈夫的父亲"] = "公公";
    relationMap["丈夫的母亲"] = "婆婆";
    relationMap["妻子的父亲"] = "岳父/丈人";
    relationMap["妻子的母亲"] = "岳母/丈母娘";
    relationMap["丈夫的哥哥"] = "大伯哥";
    relationMap["丈夫的弟弟"] = "小叔子";
    relationMap["丈夫的姐姐"] = "大姑姐";
    relationMap["丈夫的妹妹"] = "小姑子";
    relationMap["妻子的哥哥"] = "大舅子/内兄";
    relationMap["妻子的弟弟"] = "小舅子/内弟";
    relationMap["妻子的姐姐"] = "大姨子/内姐";
    relationMap["妻子的妹妹"] = "小姨子/内妹";

    // ===================== 6. 隔代/远亲 =====================
    relationMap["父亲的哥哥的儿子的女儿"] = "堂侄女";
    relationMap["父亲的哥哥的儿子的儿子"] = "堂侄子";
    relationMap["母亲的妹妹的女儿的儿子"] = "表外甥";
    relationMap["母亲的妹妹的女儿的女儿"] = "表外甥女";
    relationMap["爷爷的弟弟"] = "叔公/二爷爷";
    relationMap["奶奶的姐姐"] = "姨奶奶";
    relationMap["外公的哥哥"] = "外伯公/大外公";
    relationMap["外婆的妹妹"] = "姨外婆";

    return relationMap;
}

// 初始化称谓反向映射（称谓→路径）
map<string, string> initTitleMap() {
    map<string, string> titleMap;

    // 直系
    titleMap["爸爸"] = "父亲";
    titleMap["妈妈"] = "母亲";
    titleMap["祖父"] = "爷爷（父亲的父亲）";
    titleMap["祖母"] = "奶奶（父亲的母亲）";
    titleMap["外祖父"] = "外公（母亲的父亲）";
    titleMap["外祖母"] = "外婆（母亲的母亲）";
    titleMap["孙子"] = "儿子的儿子";
    titleMap["孙女"] = "儿子的女儿";
    titleMap["外孙"] = "女儿的儿子";
    titleMap["外孙女"] = "女儿的女儿";

    // 父系旁系
    titleMap["伯伯"] = "父亲的哥哥";
    titleMap["叔叔"] = "父亲的弟弟";
    titleMap["大姑"] = "父亲的姐姐";
    titleMap["姑姑"] = "父亲的妹妹";
    titleMap["伯母"] = "父亲的哥哥的妻子";
    titleMap["婶婶"] = "父亲的弟弟的妻子";
    titleMap["姑父"] = "父亲的姐妹的丈夫";
    titleMap["堂哥"] = "父亲的兄弟的儿子（年长于自己）";
    titleMap["堂弟"] = "父亲的兄弟的儿子（年幼于自己）";
    titleMap["堂姐"] = "父亲的兄弟的女儿（年长于自己）";
    titleMap["堂妹"] = "父亲的兄弟的女儿（年幼于自己）";

    // 母系旁系
    titleMap["舅舅"] = "母亲的兄弟（大舅=母亲的哥哥，小舅=母亲的弟弟）";
    titleMap["姨妈"] = "母亲的姐姐";
    titleMap["阿姨"] = "母亲的妹妹";
    titleMap["舅妈"] = "母亲的兄弟的妻子";
    titleMap["姨父"] = "母亲的姐妹的丈夫";
    titleMap["表哥"] = "母亲的兄弟/姐妹的儿子 或 父亲的姐妹的儿子（年长于自己）";
    titleMap["表弟"] = "母亲的兄弟/姐妹的儿子 或 父亲的姐妹的儿子（年幼于自己）";
    titleMap["表姐"] = "母亲的兄弟/姐妹的女儿 或 父亲的姐妹的女儿（年长于自己）";
    titleMap["表妹"] = "母亲的兄弟/姐妹的女儿 或 父亲的姐妹的女儿（年幼于自己）";

    // 平辈
    titleMap["哥哥"] = "年长于自己的男性平辈（同父同母/同父异母/同母异父）";
    titleMap["弟弟"] = "年幼于自己的男性平辈（同父同母/同父异母/同母异父）";
    titleMap["姐姐"] = "年长于自己的女性平辈（同父同母/同父异母/同母异父）";
    titleMap["妹妹"] = "年幼于自己的女性平辈（同父同母/同父异母/同母异父）";
    titleMap["嫂子"] = "哥哥的妻子";
    titleMap["弟妹"] = "弟弟的妻子";
    titleMap["姐夫"] = "姐姐的丈夫";
    titleMap["妹夫"] = "妹妹的丈夫";

    // 配偶亲属
    titleMap["老公"] = "丈夫";
    titleMap["老婆"] = "妻子";
    titleMap["公公"] = "丈夫的父亲";
    titleMap["婆婆"] = "丈夫的母亲";
    titleMap["岳父"] = "妻子的父亲（丈人）";
    titleMap["岳母"] = "妻子的母亲（丈母娘）";
    titleMap["大伯哥"] = "丈夫的哥哥";
    titleMap["小叔子"] = "丈夫的弟弟";
    titleMap["大姑姐"] = "丈夫的姐姐";
    titleMap["小姑子"] = "丈夫的妹妹";
    titleMap["大舅子"] = "妻子的哥哥（内兄）";
    titleMap["小舅子"] = "妻子的弟弟（内弟）";
    titleMap["大姨子"] = "妻子的姐姐（内姐）";
    titleMap["小姨子"] = "妻子的妹妹（内妹）";

    // 隔代/远亲
    titleMap["叔公"] = "爷爷的弟弟";
    titleMap["姨奶奶"] = "奶奶的姐姐/妹妹";
    titleMap["外伯公"] = "外公的哥哥";
    titleMap["姨外婆"] = "外婆的姐姐/妹妹";
    titleMap["堂侄女"] = "父亲的兄弟的儿子的女儿";
    titleMap["堂侄子"] = "父亲的兄弟的儿子的儿子";
    titleMap["表外甥"] = "母亲的姐妹的女儿的儿子";
    titleMap["表外甥女"] = "母亲的姐妹的女儿的女儿";

    return titleMap;
}

// 提取所有可输入的基础亲属关系词（核心：只提取路径里的基础词，无乱码）
set<string> getAllValidRelations(const map<string, string>& relationMap) {
    set<string> validRelations;
    for (auto& pair : relationMap) {
        string path = pair.first;
        size_t pos = 0;
        string token;
        while ((pos = path.find("的")) != string::npos) {
            token = path.substr(0, pos);
            validRelations.insert(token);
            path.erase(0, pos + 1);
        }
        if (!path.empty()) {
            validRelations.insert(path);
        }
    }
    return validRelations;
}

// 修复乱码+修正分类展示（核心：只展示validRelations里的词，分类正确）
void showAllValidRelations(const set<string>& validRelations) {
    cout << "\n===== 所有可输入的亲属关系词（分类） =====" << endl;

    // 【1. 直系亲属】（只展示validRelations里存在的直系词）
    cout << "【1. 直系亲属】：";
    vector<string> direct = { "父亲", "母亲", "儿子", "女儿", "爷爷", "奶奶", "外公", "外婆", "曾祖父", "曾祖母", "外曾祖父", "外曾祖母", "孙子", "孙女", "外孙", "外孙女" };
    bool firstDirect = true;
    for (auto& r : direct) {
        if (validRelations.count(r)) {
            if (!firstDirect) cout << "、";
            cout << r;
            firstDirect = false;
        }
    }
    cout << endl;

    // 【2. 平辈亲属】（只展示validRelations里存在的平辈词）
    cout << "【2. 平辈亲属】：";
    vector<string> peer = { "哥哥", "弟弟", "姐姐", "妹妹" };
    bool firstPeer = true;
    for (auto& r : peer) {
        if (validRelations.count(r)) {
            if (!firstPeer) cout << "、";
            cout << r;
            firstPeer = false;
        }
    }
    cout << endl;

    // 【3. 旁系核心词】（只展示validRelations里存在的旁系核心词）
    cout << "【3. 旁系核心词】：";
    vector<string> collateralCore = { "兄弟", "姐妹", "妻子", "丈夫" };
    bool firstCore = true;
    for (auto& r : collateralCore) {
        if (validRelations.count(r)) {
            if (!firstCore) cout << "、";
            cout << r;
            firstCore = false;
        }
    }
    cout << endl;

    // 【4. 隔代/远亲基础词】（只展示validRelations里存在的隔代远亲基础词）
    cout << "【4. 隔代/远亲基础词】：";
    vector<string> remoteBase = { "爷爷", "奶奶", "外公", "外婆", "曾祖父", "曾祖母", "外曾祖父", "外曾祖母" };
    bool firstRemote = true;
    for (auto& r : remoteBase) {
        if (validRelations.count(r)) {
            if (!firstRemote) cout << "、";
            cout << r;
            firstRemote = false;
        }
    }
    cout << endl;

    // 【5. 全量可输入词】（直接遍历validRelations，无乱码，换行对齐）
    cout << "【5. 全量可输入词】：";
    int cnt = 0;
    for (auto& r : validRelations) {
        cout << r << " ";
        cnt++;
        if (cnt % 10 == 0) cout << "\n                    ";
    }
    cout << "\n==========================================" << endl;
}

// 路径查称谓：找不到就返回 "亲戚"
string getTitleByPath(const string& path, const map<string, string>& relationMap) {
    auto it = relationMap.find(path);
    if (it != relationMap.end()) {
        return it->second;
    } else {
        return "亲戚";
    }
}

// 称谓查路径
string getPathByTitle(const string& title, const map<string, string>& titleMap) {
    auto it = titleMap.find(title);
    if (it != titleMap.end()) {
        return it->second;
    } else {
        return "暂不支持该称谓查询（可输入3查看所有支持的词）";
    }
}

// 无限次分步输入，实时校验输入词合法性，无效词直接提示"无法确定"并终止本次查询
string inputRelationStepByStep(const set<string>& validRelations) {
    vector<string> steps;
    string input;
    int step = 1;

    cout << "===== 无限次分步输入（输入'确认'结束） =====" << endl;
    cout << "提示：词语局限，可先输入3查看所有可输入的亲属词" << endl;

    while (true) {
        cout << "第" << step << "步：";
        getline(cin, input);

        if (input == "确认") {
            break;
        }
        if (input.empty()) {
            cout << "输入不能为空！" << endl;
            continue;
        }

        // 核心：校验输入词合法性
        if (validRelations.find(input) == validRelations.end()) {
            cout << "输入了不可识别的词：" << input << "，无法确定亲属关系，终止本次查询！" << endl;
            return "";
        }

        steps.push_back(input);
        step++;
    }

    // 拼接路径
    string path;
    for (int i = 0; i < steps.size(); i++) {
        if (i > 0) path += "的";
        path += steps[i];
    }
    return path;
}

int main() {
    map<string, string> relationMap = initRelationMap();
    map<string, string> titleMap = initTitleMap();
    set<string> validRelations = getAllValidRelations(relationMap);

    cout << "===== 亲戚计算器（最终修复版） =====" << endl;
    cout << "支持功能：" << endl;
    cout << "1. 无限次分步输入亲属路径 → 查询称谓" << endl;
    cout << "2. 输入称谓 → 查询对应亲属路径" << endl;
    cout << "3. 展示所有可输入的亲属关系词" << endl;
    cout << "词语局限，建议输入3查看所有支持的词" << endl;
    cout << "输入 '退出' 结束程序" << endl;

    string input;
    while (true) {
        cout << "\n请选择操作（1/2/3/退出）：";
        getline(cin, input);

        if (input == "退出") {
            cout << "程序结束！" << endl;
            break;
        }

        // 1: 无限分步查称谓
        if (input == "1") {
            string path = inputRelationStepByStep(validRelations);
            if (path.empty()) {
                continue;
            }
            string title = getTitleByPath(path, relationMap);
            cout << "\n查询结果：" << path << " → " << title << endl;
        }
        // 2: 称谓查路径
        else if (input == "2") {
            cout << "请输入要查询的称谓（如：伯伯、舅妈）：";
            getline(cin, input);
            string path = getPathByTitle(input, titleMap);
            cout << "查询结果：" << input << " → " << path << endl;
        }
        // 3: 展示可输入词（修复后无乱码）
        else if (input == "3") {
            showAllValidRelations(validRelations);
        }
        // 无效输入
        else {
            cout << "输入无效，请选择1/2/3或输入'退出'！" << endl;
        }
    }

    return 0;
}