DFS：深搜+回溯+剪枝实战解决OJ问题

news2024/11/14 14:23:50

✨✨✨学习的道路很枯燥，希望我们能并肩走下来!

文章目录

目录

文章目录

前言

一  排列、子集问题

1.1  全排列I

1.2  子集I 

 1.3  找出所有子集的异或总和

1.4  全排列II

1.5  字母大小写全排列

1.6  优美的排列

二  组合问题 

2.1  电话号码的数字组合

 2.2  括号生成

2.3  组合 

2.4  目标和

2.5  组合总和

三  矩阵搜索问题

3.1  N皇后 

3.2  有效的数独

3.3  解数独 

3.4  单词搜素

3.5  黄金矿工

3.6  不同路径III

总结

前言

本篇详细介绍了进一步介绍DFS，让使用者对DFS有更加深刻的认知，而不是仅仅停留在表面，更好的模拟，为了更好的使用. 文章可能出现错误，如有请在评论区指正，让我们一起交流，共同进步！

我们在做DFS的题目时，首先要把决策树（通过策略把结果不重不漏的枚举得到）画下，缕清思路，设计代码自然水到渠成

一  排列、子集问题

1.1  全排列I

46. 全排列 - 力扣（LeetCode）

 

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
    bool check[7];
public:
    vector<vector<int>> permute(vector<int>& nums) {
        dfs(nums);
        return ret;
    }

    void dfs(vector<int>& nums)
    {
        if(path.size() == nums.size())
        {
            ret.push_back(path);
            return;
        }

        for(int i = 0;i<nums.size();i++)
        {
            if(check[i] == false)
            {
                path.push_back(nums[i]);
                check[i] = true;
                dfs(nums);
                //回溯-> 恢复现场
                path.pop_back();
                check[i] = false;
            }
        }
    }
};

1.2  子集I 

78. 子集 - 力扣（LeetCode）

解法一：

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(nums,0);
        return ret;
    }

    void dfs(vector<int>& nums,int n)
    {
        if(n == nums.size())
        {
            ret.push_back(path);
            return;
        }
            //选
            path.push_back(nums[n]);
            dfs(nums,n+1);
            path.pop_back();

            //不选
            dfs(nums,n+1);
    }
};

解法二：

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(nums,0);
        return ret;
    }

    void dfs(vector<int>& nums,int pos)
    {
        ret.push_back(path);
        for(int i = pos;i<nums.size();i++)
        {
            path.push_back(nums[i]);
            dfs(nums,i+1);
            path.pop_back();
        }
    }
};

 1.3  找出所有子集的异或总和

1863. 找出所有子集的异或总和再求和 - 力扣（LeetCode）

 

class Solution {
    int sum;
    int path;
public:
    int subsetXORSum(vector<int>& nums) {
        dfs(nums,0);
        return sum;
    }

    void dfs(vector<int>& nums,int pos)
    {
        sum += path;
        for(int i = pos;i<nums.size();i++)
        {
            path^=nums[i];
            dfs(nums,i+1);
            path^=nums[i];       
        }
    }
};

1.4  全排列II

47. 全排列 II - 力扣（LeetCode）

 

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
    bool check[9];
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        dfs(nums);
        return ret;
    }

    void dfs(vector<int>& nums)
    {
        if(path.size() == nums.size())
        {
            ret.push_back(path);
            return;
        }

        for(int i = 0;i<nums.size();i++)
        {
            if(check[i] == false && (i==0 || nums[i] != nums[i-1] ||check[i-1] == true))
            {
                path.push_back(nums[i]);
                check[i] = true;
                dfs(nums);
                path.pop_back();
                check[i] = false;
            }
        }

    }
};

1.5  字母大小写全排列

784. 字母大小写全排列 - 力扣（LeetCode）

class Solution {
    vector<string> ret;
    string path;
public:
    vector<string> letterCasePermutation(string s) {
        dfs(s,0);
        return ret;
    }

    void dfs(string s,int pos)
    {
        if(pos == s.size())
        {
            ret.push_back(path);
            return;
        }
        char ch = s[pos];
        //不改变
        path += ch;
        dfs(s,pos+1);
        path.pop_back();

        //改变
        if(ch<'0' || ch>'9')
        {
            char tmp = change(ch);
            path += tmp;
            dfs(s,pos+1);
            path.pop_back();
        }
    }

    char change(char ch)
    {
        if(ch>='a'&&ch<='z')    ch-=32;
        else    ch+=32;
        return ch;
    }
};

1.6  优美的排列

526. 优美的排列 - 力扣（LeetCode）

class Solution {
    bool check[16];
    int ret;
public:
    int countArrangement(int n) {
        dfs(n,1);
        return ret;
    }

    void dfs(int n, int pos)
    {
        if(pos == n+1)
        {
            ret++;
            return;
        }

        for(int i = 1; i<=n;i++)
        {
            if(check[i] == false&&(i % pos == 0 || pos % i == 0))
            {
                check[i] = true;
                dfs(n,pos+1);
                check[i] = false;
            }
        }
    }
};

二  组合问题 

2.1  电话号码的数字组合

17. 电话号码的字母组合 - 力扣（LeetCode）

 

class Solution {
    string path;
    vector<string> ret;
    vector<string> hash = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
public:
    vector<string> letterCombinations(string digits) {
        if(digits.size() == 0)    return ret;
        dfs(digits,0);
        return ret;
    }

    void dfs(string digits,int pos)
    {
        if(pos == digits.size())
        {
            ret.push_back(path);
            return;
        }

        for(auto& ch : hash[digits[pos] - '0'])
        {
            path.push_back(ch);
            dfs(digits,pos+1);
            path.pop_back();
        }
    }
};

 2.2  括号生成

22. 括号生成 - 力扣（LeetCode）

class Solution {
    vector<string> ret;
    string path;
    int count; //记录有效括号的对数
public:
    vector<string> generateParenthesis(int n) {
        count = n;
        dfs(0,0);
        return ret;
    }

    void dfs(int left,int right)
    {
        if(path.size() == 2*count)
        {
            ret.push_back(path);
            return;
        }
        if(left<count)
        {
            path.push_back('(');
            dfs(left+1,right);
            path.pop_back();
        }
        if(right<left)
        {
            path.push_back(')');
            dfs(left,right+1);
            path.pop_back();
        }
    }
};

2.3  组合 

77. 组合 - 力扣（LeetCode）

 

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
    int n, k;
public:
    vector<vector<int>> combine(int _n, int _k) {
        n = _n;
        k = _k;
        dfs(1);
        return ret;
    }

    void dfs(int pos)
    {
        if(path.size() == k)
        {
            ret.push_back(path);
            return;
        }

        for(int i = pos; i<=n; ++i)
        {
            path.push_back(i);
            dfs(i+1);
            path.pop_back();
        }
    }
};

2.4  目标和

494. 目标和 - 力扣（LeetCode）

class Solution {
    int ret;
    int target;
public:
    int findTargetSumWays(vector<int>& nums, int _target) {
        target = _target;
        dfs(nums,0,0);
        return ret;
    }

    void dfs(vector<int>& nums, int pos, int prev)
    {
        if(pos == nums.size())
        {
            if(prev == target)
                ret++;
            return;
        }

        dfs(nums,pos+1,prev+nums[pos]);
        dfs(nums,pos+1,prev-nums[pos]);

    }
};

2.5  组合总和

39. 组合总和 - 力扣（LeetCode）

解法一：

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
    int target;
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int _target) {
        target = _target;
        dfs(candidates,0,0);
        return ret;
    }

    void dfs(vector<int>& candidates,int sum, int pos)
    {
        if(sum>target)  return;
        if(sum == target)
        {
            ret.push_back(path);
            return;
        }

        for(int i = pos;i<candidates.size();i++)
        {
            path.push_back(candidates[i]);
            dfs(candidates,sum+candidates[i],i);
            path.pop_back();
        }
    }
};

 解法二：

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
    int target;
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int _target) {
        target = _target;
        dfs(candidates,0,0);
        return ret;
    }

    void dfs(vector<int>& candidates,int sum, int pos)
    {
        
        if(sum == target)
        {
            ret.push_back(path);
            return;
        }
        if(sum>target || pos == candidates.size())  return;

        for(int k = 0;k*candidates[pos]+sum<=target;k++)
        {
            if(k)   path.push_back(candidates[pos]);
            dfs(candidates,sum+k*candidates[pos],pos+1);
        }

        for(int k = 1;k*candidates[pos]+sum<=target;k++)
        {
            path.pop_back();
        }
    }
};

三  矩阵搜索问题

3.1  N皇后 

51. N 皇后 - 力扣（LeetCode）

 

class Solution {
    bool checkCol[10], checkDig1[20], checkDig2[20];
    vector<vector<string>> ret;
    vector<string> path;
public:
    vector<vector<string>> solveNQueens(int n) {
        path.resize(n);
        for(int i = 0;i<n;i++)
            path[i].append(n,'.');
        dfs(n,0);
        return ret;
    }

    void dfs(int n, int row)
    {
        if(row == n)
        {
            ret.push_back(path);
            return;
        }

        for(int col = 0;col<n;col++)
        {
            if(!checkCol[col]&&!checkDig1[row-col+n]&&!checkDig2[row+col])
            {
                path[row][col] = 'Q';
                checkCol[col] = checkDig1[row-col+n] = checkDig2[row+col] = true;
                dfs(n,row+1);
                path[row][col] = '.';
                checkCol[col] = checkDig1[row-col+n] = checkDig2[row+col] = false;
            }
        }
    }
};

3.2  有效的数独

36. 有效的数独 - 力扣（LeetCode）

class Solution {
    bool row[9][10];
    bool col[9][10];
    bool grid[3][3][10];
public:
    bool isValidSudoku(vector<vector<char>>& board) {
        for(int i = 0;i<9;i++)
        {
            for(int j = 0;j<9;j++)
            {
                if(board[i][j] != '.')
                {
                    int num = board[i][j] -'0';
                    if(row[i][num] || col[j][num] || grid[i/3][j/3][num])
                        return false;
                    row[i][num] = col[j][num] = grid[i/3][j/3][num] = true;
                }
            }
        }

        return true;

    }
};

3.3  解数独 

37. 解数独 - 力扣（LeetCode）

 

class Solution {
    bool row[9][10];
    bool col[9][10];
    bool grid[3][3][10];
public:
    void solveSudoku(vector<vector<char>>& board) {
        for(int i = 0;i<9;i++)
        {
            for(int j = 0;j<9;j++)
            {
                if(board[i][j] != '.')
                {
                    int num = board[i][j] -'0';
                    row[i][num] = col[j][num] = grid[i/3][j/3][num] = true;
                }
            }
        }
        dfs(board);
    }

    bool dfs(vector<vector<char>>& board)
    {
        for(int i = 0;i<9;i++)
        {
            for(int j = 0;j<9;j++)
            {
               if(board[i][j] == '.')
               {
                    for(int num = 1; num<=9; num++)
                    {
                        if(!row[i][num]&&!col[j][num]&&!grid[i/3][j/3][num])
                        {
                            board[i][j] = num + '0';
                            row[i][num] = col[j][num] = grid[i/3][j/3][num] = true;
                            if(dfs(board) == true)  return true;  //判断当前所填的数是否有效
                            board[i][j] = '.';
                            row[i][num] = col[j][num] = grid[i/3][j/3][num] = false;
                        }
                    }
                    return false;  //无法填数时，则说明之前的填的数错误，返回错误
               }
               
            }
        }
        return true;
    }
};

3.4  单词搜素

79. 单词搜索 - 力扣（LeetCode）

 

class Solution {
    bool vis[7][7];
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    int m,n;
public:
    bool exist(vector<vector<char>>& board, string word) {
        m = board.size(),n = board[0].size();
        for(int i = 0;i<m;i++)
        {
            for(int j = 0;j<n;j++)
            {
                if(board[i][j] == word[0])
                {
                    vis[i][j] = true;
                    if(dfs(board,word,i,j,1))   return true;
                    vis[i][j] = false;
                }
            }
        }
        return false;
    }

    bool dfs(vector<vector<char>>& board, string word,int i,int j,int pos)
    {
        if(pos == word.size())  return true;
        for(int k = 0;k<4;k++)
        {
            int x = i + dx[k],y = j + dy[k];
            if(x >=0 && x < m && y >= 0 && y < n && !vis[x][y] && board[x][y] == word[pos])
            {
                vis[x][y] = true;
                if(dfs(board,word,x,y,pos+1))   return true;
                vis[x][y] = false;
            }
        }
        return false;
    }
};

3.5  黄金矿工

1219. 黄金矿工 - 力扣（LeetCode）

 本题的算法原理和单词搜索同，只不过多了一两个变量

class Solution {
    bool vis[16][16];
    int dx [4] = {0,0,1,-1};
    int dy [4] = {1,-1,0,0};
    int m,n,path,ret;
public:
    int getMaximumGold(vector<vector<int>>& grid) {
        m = grid.size(),n = grid[0].size();
        for(int i = 0;i<m;i++)
        {
            for(int j = 0;j<n;j++)
            {
                if(grid[i][j] != 0)
                {
                    vis[i][j] = true;
                    dfs(grid,i,j,grid[i][j]);
                    vis[i][j] = false;
                }
            }
        }
        return ret;
    }

    void dfs(vector<vector<int>>& grid,int i,int j,int path)
    {
        ret = max(ret,path);
        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >=0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] != 0)
            {
                vis[x][y] = true;
                dfs(grid,x,y,path+grid[x][y]);
                vis[x][y] = false;
            }
        }
    }
};

3.6  不同路径III

980. 不同路径 III - 力扣（LeetCode）

 

class Solution {
    bool vis[21][21];
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    int m,n,step;
    int ret;
public:
    int uniquePathsIII(vector<vector<int>>& grid) {
        int bx,by;
        m = grid.size(),n = grid[0].size();
        for(int i = 0;i<m;i++)
        {
            for(int j = 0; j < n;j++)
            {
                if(grid[i][j] == 0)     step++;
                else if(grid[i][j] == 1)
                {
                    bx = i;
                    by = j;
                }
            }
        }
        step += 2;
        vis[bx][by] = true;
        dfs(grid,bx,by,1);
        return ret;
    }

    void dfs(vector<vector<int>>& grid,int i,int j,int count)
    {
        if(grid[i][j] == 2)
        {
            if(count == step) //判断是否合法
                ret++;
            return;
        }

        for(int k = 0;k < 4;k++)
        {
            int x = i + dx[k],y = j + dy[k];
            if(x >=0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] != -1)
            {
                vis[x][y] = true;
                dfs(grid,x,y,count + 1);
                vis[x][y] = false;
            }
        }
    }
};

总结

✨✨✨各位读友，本篇分享到内容是否更好的让你理解DFS，如果对你有帮助给个👍赞鼓励一下吧！！
🎉🎉🎉世上没有绝望的处境，只有对处境绝望的人。
感谢每一位一起走到这的伙伴，我们可以一起交流进步！！！一起加油吧！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2142109.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Qt | AI+Qt6.5.3+ubuntu20.04+FFmpeg实现音视频编解码（播放一个中秋节快乐视频为例）

Qt | AI+Qt6.5.3+ubuntu20.04+FFmpeg实现音视频编解码（播放一个中秋节快乐视频为例）

点击上方"蓝字"关注我们 01、下载 >>> FFmpeg下载官网：https://ffmpeg.org// 本次选择下载linux版本的 环境准备Qt6.5.3ubuntu+虚拟机FFmpeg
阅读更多...
解决Visual Studio中OpenCV链接错误：LNK2019无法解析的外部符号

解决Visual Studio中OpenCV链接错误：LNK2019无法解析的外部符号

创作不易&#xff0c;您的打赏、关注、点赞、收藏和转发是我坚持下去的动力&#xff01; 原因分析 错误提示 LNK2019: 无法解析的外部符号 表示在编译过程中&#xff0c;链接器找不到 OpenCV 的相关函数实现。这通常是由于以下原因引起的&#xff1a; 没有正确链接 OpenCV 库&…
阅读更多...
[SaaS] FacyTech

[SaaS] FacyTech

Sora还没开源，但这家国产AIGC视频公司已经靠还原现实赚钱了我们找到了朱啸虎说“很酷”的公司https://mp.weixin.qq.com/s/rm_dylLhf4FP01c_hdU3Lw1.tryon 这图ootdiffusion+comfyui工作流吗？lora+controlnet openpose+ipa
阅读更多...
数据结构—栈

数据结构—栈

栈 概念 栈&#xff1a;一种特殊的线性表&#xff0c;其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶&#xff0c;另一端称为栈底。栈中的数据元素遵守后进先出LIFO&#xff08;Last In First Out&#xff09;的原则。 压栈&#xff1a;栈…
阅读更多...
兰花种类识别系统源码分享

兰花种类识别系统源码分享

兰花种类识别检测系统源码分享 [一条龙教学YOLOV8标注好的数据集一键训练_70全套改进创新点发刊_Web前端展示] 1.研究背景与意义 项目参考AAAI Association for the Advancement of Artificial Intelligence 项目来源AACV Association for the Advancement of Computer Vis…
阅读更多...
打印图案，输入一个整数表示输出的行数，也表示组成x的长度

打印图案，输入一个整数表示输出的行数，也表示组成x的长度

//打印图案&#xff0c;输入一个整数表示输出的行数&#xff0c;也表示组成x的长度 //打印图案&#xff0c;输入一个整数表示输出的行数&#xff0c;也表示组成x的长度 //5 //*___* //_*_*_ //__* //-*-*- //*---*- #include<stdio.h> int main() {int i 3;int j 0,…
阅读更多...
anaconda下载安装教程

anaconda下载安装教程

anaconda是python的包管理器&#xff0c;通过它来安装python库比较方便快捷&#xff0c;可以使用conda或者pip命令进行安装。 微智启软件工作室最常用的是Anaconda3-2021.11-Windows-x86_64.exe这一个版本&#xff0c;当然如果你使用其他版本也可以&#xff0c;其他版本特别是最…
阅读更多...
激光雷达点云处理—学习随记

激光雷达点云处理—学习随记

一、激光雷达基本概念 激光雷达&#xff08;Light Detection and Ranging&#xff0c;LiDAR&#xff09;&#xff0c;是一种发射激光&#xff08;可见光-近红外&#xff09;于被瞄准物体表面并记录反射光被信号接收器接收到的时间以测定距离的方法。激光雷达通过以下公式确定物…
阅读更多...
Redis学习以及SpringBoot集成使用Redis

Redis学习以及SpringBoot集成使用Redis

目录 一、Redis概述 二、Linux下使用Docker安装Redis 三、SpringBoot集成使用Redis 3.1 添加redis依赖 3.2 配置连接redis 3.3 实现序列化 3.4 注入RedisTemplate 3.5 测试 四、Redis数据结构 一、Redis概述 什么是redis&#xff1f; redis 是一个高性能的&#xf…
阅读更多...
电子电气架构---智能汽车应该是怎么样的架构？

电子电气架构---智能汽车应该是怎么样的架构？

我是穿拖鞋的汉子&#xff0c;魔都中坚持长期主义的汽车电子工程师。 老规矩&#xff0c;分享一段喜欢的文字&#xff0c;避免自己成为高知识低文化的工程师&#xff1a; 屏蔽力是信息过载时代一个人的特殊竞争力&#xff0c;任何消耗你的人和事&#xff0c;多看一眼都是你的不…
阅读更多...
rust GTK4 窗口创建与 wayland Subsurface (vulkan 渲染窗口初始化 (Linux) 上篇)

rust GTK4 窗口创建与 wayland Subsurface (vulkan 渲染窗口初始化 (Linux) 上篇)

rust 有封装好的 GTK4 库 (gtk4-rs), 有封装好的 wayland 库 (wayland-rs), 有封装好的 vulkan 库 (vulkano), 单独使用其中的每一个, 都很简单. 但是, 把这些一起使用, 崩 !! 大坑出现了 ! 这个问题的难度超出了事先的预计 (所以原计划一篇文章分成了两篇), 而类似的事情在编…
阅读更多...
【Elasticsearch系列九】控制台实战

【Elasticsearch系列九】控制台实战

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学…
阅读更多...
谷粒商城のElasticsearch

谷粒商城のElasticsearch

文章目录 前言一、前置知识1、Elasticsearch 的结构2、倒排索引 (Inverted Index)2.1、 索引阶段2.2、查询阶段 二、环境准备1、安装Es2、安装Kibana3、安装 ik 分词器 三、项目整合1、引入依赖2、整合业务2.1、创建索引、文档、构建查询语句2.2、整合业务代码 后记 前言 本篇介…
阅读更多...
【C/C++】程序的构建（编译）过程概述

【C/C++】程序的构建（编译）过程概述

&#x1f984;个人主页:小米里的大麦-CSDN博客 &#x1f38f;所属专栏:C_小米里的大麦的博客-CSDN博客 &#x1f381;代码托管:C: 探索C编程精髓&#xff0c;打造高效代码仓库 (gitee.com) ⚙️操作环境:Visual Studio 2022 目录 一、前言 二、预处理&#xff08;Preprocessi…
阅读更多...
mac安装swoole过程

mac安装swoole过程

1.很重要的是得根据自己环境的php版本来选择swoole版本&#xff01;否则都是做无用功。 Swoole 文档 2.通常pecl install swoole是安装最新版本的&#xff0c;当然安装的方式很多种&#xff0c;这里选择编译安装&#xff0c;因为可以选择不同的swoole版本进行安装&#xff0c;…
阅读更多...
鸿蒙开发入门day19-使用NDK接口构建UI（二）

鸿蒙开发入门day19-使用NDK接口构建UI（二）

(创作不易&#xff0c;感谢有你&#xff0c;你的支持&#xff0c;就是我前行的最大动力&#xff0c;如果看完对你有帮助&#xff0c;还请三连支持一波哇ヾ(&#xff20;^∇^&#xff20;)ノ&#xff09; 目录 监听组件事件 绑定手势事件 单一手势 组合手势 顺序识别 互斥…
阅读更多...
异常知识总结

异常知识总结

就是报错&#xff0c;就是不处理一下&#xff0c;程序运行到这里就直接终止了&#xff0c;输出报错信息。 但是我们用异常处理&#xff0c;能让他程序不停止不报错。 比如正常1/0程序肯定报错&#xff0c;用异常处理就不报错了。 ![在这里插入图片描述](https://i-blog.csdnim…
阅读更多...
C++笔记---二叉搜索树

C++笔记---二叉搜索树

1. 二叉搜索树的概念 二叉搜索树又称二叉排序树&#xff0c;它或者是一棵空树&#xff0c;或者是具有以下性质的二叉树: • 若它的左子树不为空&#xff0c;则左子树上所有结点的值都小于等于根结点的值。 • 若它的右子树不为空&#xff0c;则右子树上所有结点的值都大于等于…
阅读更多...
【CTF Reverse】XCTF GFSJ1092 easyEZbaby_app Writeup（Android+逆向工程+Java）

【CTF Reverse】XCTF GFSJ1092 easyEZbaby_app Writeup（Android+逆向工程+Java）

easyEZbaby_app 究极简单的安卓逆向 解法 得到一个 apk 安装包。 用 jadx 打开&#xff0c;搜索文本 flag&#xff0c;加载所有。 flag 是 obj obj2&#xff0c;来自用户的用户名和密码。 Override // android.view.View.OnClickListenerpublic void onClick(View view) {St…
阅读更多...
看Threejs好玩示例，学习创新与技术(ProjectTexture合集)

看Threejs好玩示例，学习创新与技术(ProjectTexture合集)

本文是一个合集，稍微对ProjectTexture的技术进行总结，突出关键和创意。 演示视频如下(Playing with Texture Projection in Three.js | Codrops (tympanus.net))： 20240909_232959 1、它的创新与用途？ 这个案例中模型方块游荡的方式像水波，鼠标放上面如棍子放在水里一样…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023