DFS 1253 解题报告

最新推荐文章于 2024-09-13 18:58:52 发布
最新推荐文章于 2024-09-13 18:58:52 发布
阅读量293 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/amd123456789/article/details/78874975
版权

题目的大致意思是，对于类似 xml 或者 json 格式的数据，进行增、删、改、输出。可见需要用到的算法便是 DFS。
大致思路如下：

  1. 对初始数据利用 DFS 建立一颗树，方便后续进行增、删、修改、输出。
  2. 利用哈希算法对其降低运算维度。
  3. 操作完成后，对步骤 1 进行反向 DFS,输出答案。

建树

根据题意，我们要建的树如下图：
这里写图片描述
很显然，我们需要利用 DFS 来建立它。每个节点都包含左孩子，右兄弟，当然，每个节点必须有一个父节点。指向父节点的指针没有画出来，自己脑补。
我在建立这颗树的时候，浪费了太多的时间，以致于后面没有时间进行调试。所以，必须熟练的写这个建树过程，达到能够快速码代码。

建立哈希表

一开始我只用了哈希函数，把字符串转化成一个对应的哈希值，然后单单用来进行判断而已。代码如下：

int getHashCode(char s[])
{
   ULL ret = 1;
   rint i = 0;
   while(s[i] != '\0')
   {
         ret += ((ret << 7) + s[i++] + 3); //（左移7 并且 +2 = 131）
   }
   return (ret % MAX_NODE_NUM);
}

恩，没错，我只做到这一步。那么每次我去找节点的时候，都得把所有的节点寻找一遍。如下代码：

int findNode(ULL code)
{
       for(rint i = 0; i < cnt; i++)//遍历一遍，code为计算出来的哈希值
       {
             if(node[i].isDelete)
                    continue;
             if(code == node[i].keyCode)
             {
                    return i;
             }
       }
       return -1;
}

实际上，可以利用哈希值创建一个哈希表，根据 key 直接取出结果，而不必遍历，更加优化。每次取值只需调用get()便可，建立哈希表如下：

NODE* hashMap[MAX_NODE_NUM];
//添加节点，key - value
void put(char str[], NODE* node)
{
    int key = getHashCode(str);

    if(hashMap[key] == 0)
    {
        hashMap[key] = node;
    }
    else//哈希冲突链表
    {
        node->next = hashMap[key];
        hashMap[key] = node;
    }
}

//获取节点
NODE* get(char str[])
{
    int key = getHashCode(str);

    NODE* cur = hashMap[key];

    if(cur && cur->next == 0)
        return cur;

    while(cur)//解决哈希冲突
    {
        if(isSameStr(cur->keyStr, str) == true)//直接比较字符串是否相等
            break;
        else
            cur=cur->next;
    }

    return cur;
}

增加，删除节点

这一部分，看似没什么好讲，实际上删除节点这部分，我还是踩坑了。一开始我没有采用哈希表的方法，所以删除一个节点后，没有把他的子节点全部标识为删除状态。那么在

findNode(ULL code)

的时候，会去遍历到已经删除的子节点，会导致错误。这需要递归去把他的子节点标识为删除状态。代码如下：

void markForDelete(NODE* tar)
{
    if(tar == 0)
        return;

    tar->isDelete = true;

    if(tar->leftChind)//递归遍历这颗子树
    {
        NODE* rb = tar->leftChind;
        markForDelete(rb);
        while(rb->rightBro)
        {
            rb = rb->rightBro;
            markForDelete(rb);
        }
    }
}

当然，改用哈希表的方法不需要这么处理。

总结和完整源码

这到题目的感觉就是，有思路可以做出来啊，但是就是码出不来。原因还是不熟，功力不够，针对这类型的题目还得多写代码。

1）整个核心就是建树过程，添加节点过程，删除过程。这个是最重要的。

2）一定先读懂题意，比如这道题就明确说了最多节点也就400个，要先知道题目确切的意思。确切的数据量大小。

3）先整理思路（要清晰）和搭好框架，然后填代码。


//user code

#define STRINGTYPE         0x01
#define SETTYPE            0x02
#define MAX_KEY_LENGTH     15
#define MAX_VALUE_LENGTH   127
#define MAX_MESSAGE_LENGTH 81920
#define MAX_NODE_NUM (401)
#define ULL unsigned long long
#define rint unsigned register

typedef struct NODE_
{
   int type;

   char keyStr[MAX_KEY_LENGTH];
   int keyLen;
   int keyOne;
   int keySec;

   char valueStr[MAX_VALUE_LENGTH];
   int valueLen;
   int valueOne;
   int valueSec;

   NODE_ *parent;
   NODE_ *leftChind;
   NODE_ *leftBro;
   NODE_ *rightBro;
   NODE_ *next;
}NODE;

NODE* hashMap[MAX_NODE_NUM];
NODE node[MAX_NODE_NUM];

int cnt=0;
int start = 0;
int target = 0;
NODE *Root;

//tool function
int getHashCode(char s[]);
void ztrDecodecpy(char dest[], const char src[], const int offset, const int length);
void ztrEncodeCpy(char dest[], const char src[], const int offset, const int length);
int ztrlen(const char str[]) ;
void init();
void put(char str[], NODE* node);
NODE* get(char str[]);
bool isSameStr(char s1[], char s2[]);

//build tree and revert tree
void buildSetTree(NODE *par, char in[]);
void revertSetTree(NODE* tar, char out[MAX_MESSAGE_LENGTH]);

//add & del & find node operation
void addChild(NODE* par, NODE* node, bool flag = false);
void delChild(NODE* cur);
void markForDelete(NODE* tar);
//int findNode(ULL code);

bool isSameStr(char s1[], char s2[])
{
    bool ret = false;
    int len1 = ztrlen(s1);
    int len2 = ztrlen(s2);
    if(len1 == len2)
    {
        ret = true;
        while(len1--)
        {
            if(s1[len1] != s2[len1])
            {
                ret = false;
                break;
            }
        }
    }
    return ret;
}

void put(char str[], NODE* node)
{
    int key = getHashCode(str);

    if(hashMap[key] == 0)
    {
        hashMap[key] = node;
    }
    else//哈希冲突链表
    {
        node->next = hashMap[key];
        hashMap[key] = node;
    }
}

NODE* get(char str[])
{
    int key = getHashCode(str);

    NODE* cur = hashMap[key];

    if(cur && cur->next == 0)
        return cur;

    while(cur)
    {
        if(isSameStr(cur->keyStr, str) == true)
            break;
        else
            cur=cur->next;
    }

    return cur;
}

int getHashCode(char s[])
{
   ULL ret = 1;
   rint i = 0;
   while(s[i] != '\0')
   {
         ret += ((ret << 7) + s[i++] + 3);
   }
   return (ret % MAX_NODE_NUM);
}

void init()
{
   for(rint i = 0; i < MAX_NODE_NUM; i++)
   {
        hashMap[i] = 0;
        node[i].type = 0;
        node[i].keyOne = 0;
        node[i].keyLen = 0;
        node[i].keySec = 0;
        node[i].valueLen = 0;
        node[i].valueOne = 0;
        node[i].valueSec = 0;
        for(rint j = 0; j < MAX_KEY_LENGTH; j++)
        {
            node[i].keyStr[j] = 0;
        }
        for(rint j = 0; j < MAX_VALUE_LENGTH; j++)
        {
            node[i].valueStr[j] = 0;
        }
        node[i].leftChind = 0;
        node[i].rightBro = 0;
        node[i].parent = 0;
        node[i].leftBro = 0;
        node[i].next = 0;
   }
   cnt = 0;
   start = 0;
   target = 0;
   Root = &node[cnt++];
}

void ztrDecodecpy(char dest[], const char src[], const int offset, const int length) 
{
    int pos = 0;
    while (pos < length && src[pos + offset] != '\0') {
        dest[pos] = src[pos + offset];
        ++pos;
    }
    dest[pos] = '\0';
}

void ztrEncodeCpy(char dest[], const char src[], const int offset, const int length) {
    int pos = 0;
    while (pos < length && src[pos] != '\0') {
        dest[offset + pos] = src[pos];
        ++pos;
    }
}

int ztrlen(const char str[]) 
{  
    int pos = 0;
    while(str[pos] != '\0')
        ++pos;
    return pos;
}

void addChild(NODE* par, NODE* node, bool flag)
{
    if(par == 0 || node == 0)
        return;

    put(node->keyStr, node);
    node->parent = par;

    if(!par->leftChind)
    {
        par->leftChind = node;
    }
    else
    {
        NODE* rb = par->leftChind;
        while(rb->rightBro)
        {
            rb = rb->rightBro;
        }
        rb->rightBro = node;
    }

    if(flag == true)
    {
        par->valueLen++;
        par->valueSec = (par->valueLen & 0xff);
        par->valueOne = (par->valueLen >> 8);
    }
}

void delChild(NODE* cur)
{
    if(!cur)
        return;

    NODE* par = cur->parent;

    if(!par)
        return;

    NODE* rb = par->leftChind;
    bool isFind = false;
    if(rb == cur)
    {
        par->leftChind = rb->rightBro;
        rb->leftBro = 0;
        isFind = true;
    }
    else
    {
        while(rb->rightBro)
        {
            if(rb->rightBro == cur)
            {
                isFind = true;
                break;
            }
            else
            {
                rb = rb->rightBro;
            }
        }
    }

    if(isFind)
    {
        rb->rightBro = cur->rightBro;
        par->valueLen--;
        par->valueOne = par->valueLen >> 8;
        par->valueSec = par->valueLen & 0xff;
    }
}
void buildSetTree(NODE *par, char in[])
{

    int type = in[start];
    start++;

    NODE* cur = &node[cnt++];
    cur->type = type;

    //key
    cur->keyOne = in[start++];
    cur->keySec = in[start++];
    cur->keyLen = (cur->keyOne >> 8) + cur->keySec;
    ztrDecodecpy(cur->keyStr, in, start, cur->keyLen);

    //value
    start += cur->keyLen;
    cur->valueOne = in[start++];
    cur->valueSec = in[start++];
    cur->valueLen = (cur->valueOne >> 8) + cur->valueSec;

    if(type == STRINGTYPE)
    {
        ztrDecodecpy(cur->valueStr, in, start, cur->valueLen);
        start += cur->valueLen;
    }
    else
    {
        //build child
        for(rint i = 0; i < cur->valueLen; i++)
        {
            buildSetTree(cur, in);
        }
    }

    addChild(par, cur);

}

void revertSetTree(NODE* tar, char out[MAX_MESSAGE_LENGTH])
{
    int type = tar->type;
    out[target++] = type;
    out[target++] = tar->keyOne;
    out[target++] = tar->keySec;
    ztrEncodeCpy(out, tar->keyStr, target, tar->keyLen);
    target += tar->keyLen;

    out[target++] = tar->valueOne;
    out[target++] = tar->valueSec;
    if(type == STRINGTYPE)
    {
        ztrEncodeCpy(out, tar->valueStr, target, tar->valueLen);
        target += tar->valueLen;
    }
    else
    {
        if(tar->leftChind)
        {
            NODE* rb = tar->leftChind;
            revertSetTree(rb, out);
            while(rb->rightBro)
            {
                rb=rb->rightBro;
                revertSetTree(rb, out);
            }
        }
    }
}

void parse(char in[MAX_MESSAGE_LENGTH], int size)
{
    init();
    buildSetTree(Root, in);
}

void set(char targetkey[MAX_KEY_LENGTH + 1], char newvalue[MAX_VALUE_LENGTH + 1])
{
    int len = ztrlen(newvalue);

    NODE* cur = get(targetkey);

    if(cur == 0)
        return;

    cur->valueLen = len;
    cur->valueOne = len >> 8;
    cur->valueSec = len & 0xff;
    ztrDecodecpy(cur->valueStr, newvalue, 0, len);
}

void add(char parentkey[MAX_KEY_LENGTH + 1], char childkey[MAX_KEY_LENGTH + 1], char childvalue[MAX_VALUE_LENGTH + 1])
{
    int keyLen = ztrlen(childkey);
    int valueLen = ztrlen(childvalue);

    NODE* par = get(parentkey);
    NODE* cur = &node[cnt++];
    cur->type = STRINGTYPE;

    cur->keyOne = keyLen >> 8;
    cur->keySec = keyLen & 0xff;
    cur->keyLen = keyLen;
    ztrDecodecpy(cur->keyStr, childkey, 0, cur->keyLen);

    cur->valueOne = valueLen >> 8;
    cur->valueSec = valueLen & 0xff;
    cur->valueLen = valueLen;
    ztrDecodecpy(cur->valueStr, childvalue, 0, cur->valueLen);
    addChild(par, cur, true);
}

void erase(char targetkey[MAX_KEY_LENGTH + 1])
{
    NODE* cur = get(targetkey);

    if(cur == 0)
        return;

    delChild(cur);
}

int generate(char targetkey[MAX_KEY_LENGTH + 1], char out[MAX_MESSAGE_LENGTH])
{

    target = 0;

    NODE* tar = get(targetkey);

    if(tar == 0)
        return target;

    revertSetTree(tar, out);
    out[target] = '\0';

    return target;
}
hai2024
关注
DFS常规解题套路
ppprog的博客
06-20 1142
0 前言 昨天突然的代码训练营被叫起来讲两周前的一道题，有点懵，有同学听完之后表示没太明白，可能我当时表述的比较着急所以没讲清楚。现在特别整理了一下DFS的解题模板，并挑选了一系列leetcode的相关题目(从easy到hard)，希望大家看完之后能对DFS有个更好的认识。 本文内容比较基础，只适用于对DFS了解不深的同学；不过欢迎所有的同学交流和指正，大家一起努力提高~ 1 DFS简介： 引用自leetcode网站关于DFS的介绍 深度优先搜索算法（英语：Depth-First-Search，DFS）是
DFS解题思路
Qin_酱的博客
08-17 974
1.理论知识： 深度优先搜索算法（英语：Depth-First-Search，简称DFS）是一种用于遍历或搜索树或图的算法。沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。属于盲目搜索。 2.条件 在设计DFS函数的时候，首先写的语句就是弹出终止语句。之后才是递归的语句，否则会
2020C语言程序设计1253,1253【C语言程序设计A】2009-2011
weixin_42106299的博客
05-17 407
《1253【C语言程序设计A】2009-2011》由会员分享，可在线阅读，更多相关《1253【C语言程序设计A】2009-2011(10页珍藏版)》请在人人文库网上搜索。1、2009.7一、单选题(每小题2分，共20分1.由C语言源程序文件编译而成的目标文件的缺省扩展名为(D.obj)。2.设x和y均为逻辑值，则x!y为假的条件是(C.它们均为假)。3.枚举类型中的每个枚举常量的值都是一个(A.整...
DFS 解题套路
努力中的老周的专栏
03-17 2067
DFS 解题套路 如果碰到一个 DFS 题目，基本的代码套路如下： 1、我们基本都是使用递归来解决 DFS 问题，因此要确定递归的结束条件，也就是 DFS 结束条件。 2、写 DFS 函数套路框架。如下所示 void dfs() { } int main() { 读入数据 dfs(); return 0; } 3、确认 DFS 函数的参数。这个是最难的地方...
DFS解题
weixin_53459056的博客
03-21 742
DFS的主要思想 使用栈保存未被检测的结点，结点按照深度优先的次序被访问并依次被压入栈中，并以相反的次序出栈进行新的检测 DFS解题时通常用到两个数组 一个用来标记该点是否被访问过 一个用来把该点放入 从一个走迷宫常用的解题模板引入： const int maxn = 100; //最大范围 bool visit[maxn][maxn]; // 访问标记 int map[maxn][maxn]; // 坐标范围 int dir[4][2] = { 0,1, 0,-1,
dfs解题思路详解
weixin_51729270的博客
02-12 446
给你一个大小为 m x n 的二进制矩阵 grid ，其中 0 表示一个海洋单元格、1 表示一个陆地单元格。 一次 移动 是指从一个陆地单元格走到另一个相邻（上、下、左、右）的陆地单元格或跨过 grid 的边界。 返回网格中 无法 在任意次数的移动中离开网格边界的陆地单元格的数量。 这是一道典型的dfs题,这里首先要确定拿到哪几个方向的深度优先; for(int j=0;j<n;j++){ dfs(grid,0,j); dfs(grid,m-1,j); } for(int i=0;i&
DFS树的解题模板
weixin_47755728的博客
05-29 760
DFS：优先考虑深度，换句话说就是一条路走到黑，直到无路可走的情况下，才会选择回头，然后重新选择一条路。是遍历或者的一种算法，本质就是。
李白打酒解题报告（dfs）
Lemon的博客
08-07 1218
问题描述： 话说大诗人李白，一生好饮。幸好他从不开车。 一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱： 无事街上走，提壶去打酒。 逢店加一倍，遇花喝一斗。 这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。 请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb就是合理的次序。 像这样的答案一共有多少呢？...
DFS解题套路总结
majichen95的博客
02-23 1496
一、组合问题 题目要求的结果是当前排列的分割！对于长度为n的数组，我们需要依次确认每个位置上的元素。初始问题：从a[0]开始依次确认n个元素。如果我们确认a[0]之后，问题就变成从a[1]开始从剩余元素中选择一个元素确定a[1]。每次选择都有多种可能性，我们依次尝试（尝试后还原），并递归解决选择之后的产生的子问题，并定义出口。 例如给出初始集合[1, 2, 3]，则结果应该是[1, 2, 3...
最大Xor路径 - 解题报告
Gary的博客
02-01 428
最大Xor路径 | 解题报告 标签（空格分隔）： 编程 解题报告 最大Xor路径 解题报告 算法1 - 暴力的DFS 算法2 - 一个无用的优化 算法3 - 终极版优化 代码Pascal 算法链接 Description 求出这棵带边权的树的一条最大Xor路径 Input 第一行，一个整数N，表示一颗树有N个节点，接下来N-1行，每行三个整数
lanqiao_杭电ACMOJ解题报告_规划_
09-29
【标题】"lanqiao_杭电ACMOJ解题报告_规划_" 涉及的是ACM（国际大学生程序设计竞赛）领域的编程题目解决策略和优化规划。在这个压缩包中，包含了不同类型的算法实现，旨在帮助程序员提高解决ACM竞赛问题的能力。 ...
ZOJ解题报告ZOJ解题报告
08-02
### ZOJ解题报告：深入理解与策略分析 #### 一、FireNet1002：网络流量分析与优化 在FireNet1002问题中，主要考察的是网络流量管理和优化技术。该问题通常涉及到如何在有限的带宽资源下，合理分配网络流量，以确保...
usaco5.3解题报告1
08-03
【标题】"usaco5.3解题报告1"涉及的主要知识点是算法设计与分析，具体包括搜索算法、动态规划（DP）以及强连通分量（SCC）的运用。该题目的背景是农夫约翰需要购买桶来量取牛奶，目标是最小化桶的数量并确保能准确量...
树Tree深度优先搜索DFS解题套路【LeetCode刷题套路教程9】
08-30
树Tree深度优先搜索DFS解题套路【LeetCode刷题套路教程9】
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 563
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 335
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1253
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
leetcode 2398.预算内的最多机器人数目
最新发布
m0_53899788的博客
09-13 470
需要注意的是，题目询问中连续是子数组的意思，即求满足条件的最长子数组的长度。因为是连续的，所以可以用双指针扫描整个数组。每次将右指针r向右移动一个位置，然后左指针l向右移动到满足 budget 限制的位置。判断区间 [l,r] 是否满足budget 限制。在扫描时，可以用一个变量维护区间 cost 的和，也可以通过前缀和来得到 sum(cost)。除此之外，需要这段区间 times 的最大值，维护一个非严格递减的单调队列，队首元素是这段区间 times 的最大值。在将左指针l。
算法基础-约数
qq_65186476的博客
09-11 344
试除法求约数、约数个数、约数之和、最大公约数
深度优先搜索(DFS)在树上问题的应用与解题策略
"这篇资源主要介绍了树的深度优先搜索（DFS）序及其在解决竞赛编程问题中的应用，适合OI（奥林匹克信息学）参赛者学习。文章通过实例展示了DFS序的概念，以及如何利用DFS序转化为序列问题，结合数据结构如ST表、树状...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值