HNUCMOJ_题解

已于 2022-05-04 16:51:43 修改
阅读量494 收藏
点赞数 1
分类专栏： 题目 文章标签： 算法 java 动态规划
于 2022-04-30 03:55:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52949203/article/details/124507644
版权

2022年春季学期《算法分析与设计》练习9

问题A ：最大子段和

这个题没啥要注意的，就是记得不要和我一样没注意多组输入
AC代码：
1、DP

import java.util.Scanner;
 
public class Main {
 
 
    public static int solve(int[] a) {
        int maxSum = Integer.MIN_VALUE;
        int tempSum = 0;
        int begin = 0;
 
        for (int i = 0; i < a.length; i++) {
            if (tempSum > 0)
                tempSum += a[i];
            else {
                tempSum = a[i];
                begin = i;  //标记
            }
 
            if (tempSum > maxSum) {
                maxSum = tempSum;
                //可以在这里获取最佳连续子序列和的起点位置begin和重点位置i
            }
 
        }
        return maxSum;
    }
 
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        while(sc.hasNext()){
            int n=sc.nextInt();
            int[]arr=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=sc.nextInt();
            }
            System.out.println(solve(arr));
        }
 
    }
}

2、枚举 O(n^2)

import java.util.Scanner;
 
public class Main {
 
 
    public static int solve(int[] a) {
        int maxSum = Integer.MIN_VALUE;
        int begin = 0;
 
        for (int i = 0; i < a.length; i++) {
            int tempSum = 0;
            for (int j=i;j<a.length;j++){
                tempSum+=a[j];
                if(tempSum>maxSum){
                    maxSum=tempSum;
                }
            }
        }
        return maxSum;
    }
 
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        while(sc.hasNext()){
            int n=sc.nextInt();
            int[]arr=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=sc.nextInt();
            }
            System.out.println(solve(arr));
        }
 
    }
}
问题B、最大子段和升级版

AC：

import java.util.Scanner;
 
public class Main {
    public static String solve(int[] a) {
        int maxSum =Integer.MIN_VALUE;
        int tempSum = 0;
        int begin = 0,bg2=0;
        int end=0;
 
        for (int i = 0; i < a.length; i++) {
            if (tempSum > 0)
                tempSum += a[i];
            else {
                tempSum = a[i];
                begin = i+1;  //标记
            }
 
            if (tempSum > maxSum) {
                maxSum = tempSum;
                end=i+1;
                bg2=begin;
                //可以在这里获取最佳连续子序列和的起点位置begin和重点位置i
            }
 
        }
        return maxSum+" "+bg2+" "+end;
    }
 
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        while(sc.hasNext()){
            int n=sc.nextInt();
            int[]arr=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=sc.nextInt();
            }
            System.out.println(solve(arr));
        }
 
    }
}

问题C 、斜线最大最小值

AC:

import java.util.Scanner;
 
public class Main {
static int L[]=new int[1000]; //用来放每一斜线的最大值
static int S[]=new int[1000];//用来放每一斜线的最小值
static int a[][];
    public static void main(String[] args) {
        // TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
while(sc.hasNext()) {
    int n=sc.nextInt();
     a=new int[n][n];
    for(int i=0;i<n;i++) {
        for(int j=0;j<n;j++) {
            a[i][j]=sc.nextInt();
        }
    }
    for(int r=1;r<=n;r++) {//r表示从主对角线开始第r行
        L[r]=a[0][r-1];//初始化
        S[r]=a[0][r-1];
        for(int p=1;p<=n-r;p++) {
            int q=r-1+p;//有逻辑关系q-p=r-1
            if(a[p][q]>L[r]) {L[r]=a[p][q];}
            if(a[p][q]<S[r]) {S[r]=a[p][q];}
        }
    }
    for(int k=1;k<n+1;k++) {
    System.out.println("L"+k+"="+L[k]+", S"+k+"="+S[k]);
     
    }
     
     
}
    }
 
}

问题D 、矩阵连乘问题-备忘录法求最优值

AC:

import java.util.Scanner;
 
public class Main {
 
    static int[][] m;
    static int[] p;
 
    private static int lookupChain(int i, int j) {
        if(m[i][j]>0) return m[i][j];//表示已经算过就直接用
        if(i==j) return 0;//i=j就是一个矩阵，不进行乘法
        int u=lookupChain(i,i)+lookupChain(i+1,j)+p[i-1]*p[i]*p[j];//初始化最小值，在i后面分割
        for(int k=i+1;k<j;k++) {
            int f=lookupChain(i,k)+lookupChain(k+1,j)+p[i-1]*p[k]*p[j];
            if(f<u) {u=f;}//有了更小的加括号组合
            //m数组是用来保存从第i个矩阵到第j个的最少乘法次数
        }
        m[i][j]=u;
        return u;
    }
 
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()) {
            int n=sc.nextInt();
            p=new int[n];
            m=new int[n][n];
            for(int i=0;i<n;i++) {
                for(int j=0;j<n;j++) {
                    m[i][j]=0;
                }
            }//初始化
            for(int i=0;i<n;i++) {
                p[i]=sc.nextInt();
            }
            int t=lookupChain(1,n-1);//求的是第一个矩阵到第n-1个矩阵的最小连乘次数
            System.out.println(t);
 
        }
    }
}

问题E、矩阵连乘问题-动态规划求最优值

AC：

import java.util.Scanner;
 
public class Main {
    static int m[][];
    static int p[];
    static int n;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()) {
            n=sc.nextInt();
            p=new int[n];
            m=new int[n][n];
            /*
             * for(int i=0;i<n;i++) { for(int j=0;j<n;j++) { m[i][j]=0; } }
             */
            for(int i=0;i<n;i++) {
                p[i]=sc.nextInt();
            }
            int t=matrixChain(n,p,m);
            System.out.println(t);
 
        }
 
    }
    private static int matrixChain(int n,int[] p, int[][] m) {
        // TODO Auto-generated method stub
        int n1=n-1;//为什么是n-1呢，因为其实m数组是放第几个矩阵乘至第几个矩阵的最小次数，p有n个维数，其实是n-1个矩阵
        for(int i=1;i<=n1;i++) {m[i][i]=0;}//主对角线置0,m数组从(1,1)开始放元素
        for(int r=2;r<=n1;r++) {//第r行对角线
            for(int i=1;i<=n1-r+1;i++) {//每条对角线从第1行到第n-r+1行
                int j=r-1+i;
                m[i][j]=m[i][i]+m[i+1][j]+p[i-1]*p[i]*p[j];//初始化每个m[i][j]看作最小
                for(int k=i+1;k<j;k++) {
                    int f=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
                    if(f<m[i][j]) {//找到更小的赋给m[i][j]
                        m[i][j]=f;
                    }
                }
            }
        }
        return m[1][n1];
 
 
    }
}

问题F、 矩阵连乘问题-构造最优解

AC：

import java.util.Scanner;
 
public class Main {
    static int m[][],s[][];
    static int p[];
    static int n;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()) {
            n=sc.nextInt();
            p=new int[n];
            m=new int[n][n];
            s=new int[n][n];
            /*
             * for(int i=0;i<n;i++) { for(int j=0;j<n;j++) { m[i][j]=0; } }
             */
            for(int i=0;i<n;i++) {
                p[i]=sc.nextInt();
            }
            int t=matrixChain(n,p,m);
//            System.out.println(t);
            traceback(s,1,n-1);
//            for(int i=1;i<n;i++){
//                for(int j=1;j<n;j++){
//                    System.out.print(s[i][j]+" ");
//                }
//                System.out.println();
//            }
 
        }
 
    }
 
    public static void traceback(int [][]s,int i,int j) {
        if(i==j) {
            return;
        }
        traceback(s,i,s[i][j]);
        traceback(s,s[i][j]+1,j);
        System.out.println("A[" + i + ":" + s[i][j]+ "] * A[" + (s[i][j]+1) + ":" +j+ "]");
    }
 
 
    private static int matrixChain(int n,int[] p, int[][] m) {
        // TODO Auto-generated method stub
        int n1=n-1;//为什么是n-1呢，因为其实m数组是放第几个矩阵乘至第几个矩阵的最小次数，p有n个维数，其实是n-1个矩阵
        for(int i=1;i<=n1;i++) {m[i][i]=0;}//主对角线置0,m数组从(1,1)开始放元素
        for(int r=2;r<=n1;r++) {//第r行对角线
            for(int i=1;i<=n1-r+1;i++) {//每条对角线从第1行到第n-r+1行
                int j=r-1+i;
                m[i][j]=m[i][i]+m[i+1][j]+p[i-1]*p[i]*p[j];//初始化每个m[i][j]看作最小
                s[i][j]=i;
                for(int k=i+1;k<j;k++) {
                    int f=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
                    if(f<m[i][j]) {//找到更小的赋给m[i][j]
                        m[i][j]=f;
                        s[i][j]=k;
                    }
                }
            }
        }
        return m[1][n1];
 
 
    }
}

问题G 、石子合并问题

注意多组输入！！

package DP;

import java.util.Scanner;

public class stoneMG_dp {

    static int arr[];//用来存每一堆石头的数量
    static int dp[][];//用来存第i堆加到第j堆的代价，dp[i][i]=0;
    static int sum[][];//用来存第i堆到第j堆的和,sum[i][i]等于石堆的数量arr[i];

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            int n=sc.nextInt();
            arr=new int[n+1];
            dp=new int[n+1][n+1];
            sum=new int[n+1][n+1];

            for(int i=1;i<n+1;i++){
                arr[i]=sc.nextInt();//输入每一个石堆的值
                sum[i][i]=arr[i];//sum[i][i]等于石堆的数量arr[i];
            }
            for(int i=1;i<n+1;i++){
                for(int j=i+1;j<n+1;j++){
                    sum[i][j]=sum[i][j-1]+arr[j];//sum[i][j]表示的是从第i堆到第j堆之间求和的结果
                }
            }
            //至此，准备工作已就绪
            //dp开始
            solve(n);
            //输出右上角
            System.out.println(dp[1][n]);
        }
        sc.close();
    }

    static void solve(int n){
        for(int i=1;i<n+1;i++){
            dp[i][i]=0;//填第一条对角线
        }
        for(int r=2;r<=n;r++){//一共有n条对角线，上面的for里面填了第一条，这里从第二条开始
            for(int i=1;i<=n-r+1;i++){//对对角线遍历，对于第r条对角线，它所跨的行数是n-r+1(规律)
                //第r条对角线上列（j）与行（i）的规律j-i=r-1;
                int j=i+r-1;
                dp[i][j]=dp[i][i]+dp[i+1][j]+sum[i][j];//默认先从i后面分开
                for(int k=i+1;k<j;k++){//逐点分开找到最小的那个
                    dp[i][j]=Math.min(dp[i][j],dp[i][k]+dp[k+1][j]+sum[i][j]);
                }
            }
        }
    }
}

问题H 、XP的矩阵

感谢这里的思路提醒

import java.util.Scanner;

public class XP_juzheng {

    static int[][]arr,min;
    static int M,N;
    static void solve(){
        min[1][1]=arr[1][1];
        for(int i=2;i<=M;i++){
            min[i][1]=arr[i][1]+min[i-1][1];
        }
        for(int j=2;j<=N;j++){
            min[1][j]=arr[1][j]+min[1][j-1];
        }
        for(int i=2;i<=M;i++){
            for(int j=2;j<=N;j++){
                min[i][j]=Math.min(min[i][j-1],min[i-1][j])+arr[i][j];
            }
        }
    }

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        while(t>0){
            --t;
            arr=new int[1010][1010];
            min=new int[1010][1010];
            M=sc.nextInt();
            N=sc.nextInt();
            for(int i=1;i<=M;i++){
                for(int j=1;j<=N;j++){
                    arr[i][j]=sc.nextInt();
                }
            }
            solve();
            System.out.println(min[M][N]);

//            for(int i=1;i<=M;i++){
//                for(int j=1;j<=N;j++){
//                    System.out.print(min[i][j]+" ");
//                }
//                System.out.println();
//            }//这个用来检测是否正确
        }
    }
}

写在最后：慢慢来，总会遇到困难的，慢慢来。

是君倩
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
树链剖分_题解_
10-03
树链剖分，luoguP3384 【模板】重链剖分
大整数的因子_题解noip_源码
10-04
题解：对于一个大整数，如何求他的个位数因子？高精度除法不容易实现，但求余数可以用低精度的方式。
HNUCMOJ题解
m0_52949203的博客
04-21 3115
HNUCMOJ 2022年春季学期《算法分析与设计》练习8 前6题为必做题，最后2题为选做题！ 写在前面： 题目还是没那么难的，只是有些东西不好理解，可以像老师一样画图帮助理解 1、 问题 A: 数字三角形之动态规划法 AC代码： import java.util.Arrays; import java.util.Scanner; public class Main { public static int n; public static int[][]arr,Maxsum;
HNUCM-OJ（中等难度）--java实现
qq_45353823的博客
05-11 1408
题目描述 数列A1,A1,…,AN ，修改最少的数字，使得数列严格单调递增。 输入 第 1 行，1 个整数 N 第 2 行，N 个整数 A1,A1,…,AN 。（1 ≤ N ≤ 10^5,1≤ Ai ≤10^9） 输出 1 个整数，表示最少修改的数字 。 样例输入 Copy 3 1 2 3 5 1 2 9 3 4 样例输出 Copy 0 1 思路： 维护一个单调队列，这个队列的元素是严格单调递增的...
hnucm_oj 算法分析与设计 练习14
wobuxiangxin1314的博客
06-03 578
hnucm_oj 算法分析与设计 练习14问题 A: 菱形图案问题 B: 牛妹的蛋糕问题 C: 尼科彻斯定理问题 D: ABC + DEF = GHI问题 E: 油田问题问题 F: 马的遍历问题 湖中大OJ 问题 A: 菱形图案 题目描述 KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的菱形图案。 输入 多组输入，一个整数（2~20）。 输出 针对每行输入，输出用“”组成的菱形，每个“”后面有一个空格。每输出一个菱形的后面需要空一行。 样例输入 2 3 4 样例输出
HNUCM-OJ 2022年寒假训练赛（一）
qq_46022761的博客
01-18 805
HNUCM-OJ 2022年寒假训练赛（一）
复习题（1）
weixin_53488675的博客
06-20 729
这里写目录标题问题 A: yangftc的时间安排一级目录一级目录一级目录一级目录一级目录一级目录 问题 A: yangftc的时间安排 题目描述 yangftc需要安排他的时间，有很多事情做，每个事情都有固定的开始和结束时间，因为yangftc每次只能做一件事情，如果有两个或者多个事情的时间重合了那么他就会说 NO，否则他就会说 YES 。 输入 第一个数字t代表样例数量， 后面t个样例，每个样例输入一个n表示事情的数量，后面n行每行两个数字l r表示这个事情的开始和结束时间； 输出 判断yangftc
HNUCM-OJ-2023年春季学期《算法分析与设计》练习12
m0_73492012的博客
05-26 263
从第2行开始，接下来的m行表示每辆汽车的司乘人员总人数和人员编号（人员编号是一个固定值，可以对应于我们的身份证号码），每一行的第1个数字k表示该汽车的司乘人员总数，接下来的k个数字表示每一个人的编号。第2行到第m+1行对应m对电子元件及其对应的奖励积分值，每一行包含三个正整数，第1个和第2个整数表示电子元件编号（从1开始），第3个整数表示两个元件之间搭建电路的奖励积分num(num
leetcode题解_leetcode_leetcode题解_
09-29
leetcode题解 算法和数据结构题目及解答
历年题_CCF题解_
10-04
CCF题目解答
Leetcode_回文数_题解_19.9.21_21|19_leetcode_C++_
09-28
判断字符串是否为回文数，leetcode原题，使用多种方法
HNUCM-OJ算法练习13(JAVA,C)
qq_45353823的博客
05-20 877
算法练习13问题 A: 牛妹的蛋糕问题 B: 尼科彻斯定理问题 C: 油田问题问题 D: ABC + DEF = GHI问题 E: 马的遍历问题 问题 A: 牛妹的蛋糕 题目描述 众所周知，牛妹非常喜欢吃蛋糕。 第一天牛妹吃掉蛋糕总数三分之一多一个，第二天又将剩下的蛋糕吃掉三分之一多一个，以后每天吃掉前一天剩下的三分之一多一个，到第n天准备吃的时候只剩下一个蛋糕。 牛妹想知道第一天开始吃的时候蛋糕一共有多少呢？ 输入 输入n，0<n< 30。 输出 输出第一天蛋糕的数量。 样例输入 Copy 2
2022年春季学期《算法分析与设计》练习12
m0_52949203的博客
05-28 684
问题 A: XP的素数 题目描述 XP最近对素数很痴迷，特别是那些特殊的素数，其中有一类素数被称为孪生素数。其定义如下：如果一个数k是素数，k+2也是素数，那么k和k+2成为一对孪生素数。请计算一个给定区间m和n（0<m<n）中孪生素数对的个数。 输入 单组输入数据 m n (0<m<n<1000) 输出 请输出一行结果:区间[m,n]中孪生素数对的个数 样例输入 1 999 样例输出 35 import java.util.Scanner; public class Mai
计科练习11题解(贪心)
Y_yunhu的博客
07-17 1283
XP的素数 :https://blog.csdn.net/Y_yunhu/article/details/84714313 XP的三角形:https://blog.csdn.net/Y_yunhu/article/details/84714824 XP的小视频:https://blog.csdn.net/Y_yunhu/article/details/84714460 图书排序 题目...
搭建电路（最大生成树）
m0_52949203的博客
06-02 980
明明迷上了一个搭建电路的游戏。 在游戏中，每次在两个电子元件之间增加一条有效电路（两个元件之间先前没有电路相连）都将获得相应的积分奖励。 已知电子元件数量n和部分电子元件之间的奖励积分值。如何构建一个有效电路将所有元件全部连接起来，并且可以得到最多的积分奖励。每组输入数据包含m+1行。 第1行输入两个正整数n和m，其中n表示电子元件数量（n
手机短号--题目
m0_52949203的博客
02-03 288
手机短号 大家都知道，手机号是一个11位长的数字串，同时，作为学生，还可以申请加入校园网，如果加入成功，你将另外拥有一个短号。假设所有的短号都是是 6+手机号的后5位，比如号码为13512345678的手机，对应的短号就是645678。 现在，如果给你一个11位长的手机号码，你能找出对应的短号吗？ Input 输入数据的第一行是一个N(N <= 200)，表示有N个数据，接下来的N行每一行为一个11位的手机号码。 Output 输出应包括N行，每行包括一个对应的短号，输出应与输入的顺序一致。 Samp
《算法分析与设计》练习11
m0_52949203的博客
05-18 261
问题 A: 月饼 import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Scanner; public class Main { static class moonKake implements Comparable<moonKake>{ private double value; private double
《算法分析与设计》练习10
m0_52949203的博客
05-15 214
问题 A: 最长递增子序列 注意数组大小，可能有测试数据范围导致的运行错误 import java.util.Scanner; public class Main { static int[] a=new int[1010];//存原数据 static int[] b=new int[1010];//b[i]为以a[i]为单调递增子序列最后一个元素时所得的最长单调子序列的和 static int[] pre=new int[1010];//存前一个的位置 static i
bugkuctfweb题解simple_ssti_1
最新发布
06-28
### 回答1： simple_ssti_1 是一个使用 Flask 框架编写的 web CTF 题目，主要涉及到服务器端模板注入 (Server-Side Template Injection, SSTI) 的问题。 这个题目中，使用者可以在输入框中输入任意字符串，然后后端会将这个字符串嵌入到一个 Flask 模板中，并将渲染后的页面返回给用户。攻击者可以在输入框中输入包含 SSTI 代码的字符串，从而在服务器上执行任意代码。 为了解决这个问题，可以使用 Flask 的 Jinja2 模板引擎提供的 safe 过滤器来过滤用户输入，防止用户输入的字符串被作为代码执行。或者在编写模板时，尽量避免使用可执行的表达式，而是将变量放在 HTML 标签中输出。 这个题目是一个很好的 SSTI 注入练习题目，可以帮助我们了解 SSTI 注入的危害和防御方法。 ### 回答2： Simple_ssti_1是BugsKiller CTF比赛中的一道Web题目，考察的知识点是SSTI(Server-Side Template Injection)模板注入，需要寻找漏洞点并利用SSTI漏洞构造payload，达到读取/执行任意代码的目的。 首先，我们下载题目附件simple_ssti_1.zip，获得题目源代码及相关文件。查看代码，发现以下几点： 1. 程序的入口是index.php文件，包含了一个GET参数tpl，可控注入的点在这里。 2. 向模板文件simple_ssti_1_template.html中传入tpl参数，在该文件中执行了{{tpl}}操作，将tpl参数进行了模板渲染。 3. SSTI的注入点在于，如果我们的攻击payload中包含了一些特殊模板语法的操作符，如{{3*3}}、{{config}}等，这些操作符会被解析器自动执行，导致代码注入进去。 从上述代码的分析可知，我们首先需要构造包含有SSTI操作符的payload才能进行下一步的SSTI构造。继续观察代码，我们发现一个{{config}}变量被渲染在了simple_ssti_1_template.html的头部中，我们可以通过注入payload来构造一个同名的config变量，从而读取根目录的敏感文件/flag.php。 构造payload : {{config.__class__.__init__.__globals__['os'].popen('cat flag.php').read()}} 这个SSTI注入的payload实现了直接运行命令cat flag.php然后读取文件的操作。注入的{{config}}变量实际上是一个自定义的config字典，含有很多内置函数，比如__class__.__init__.__globals__，它的作用是获取全局变量__builtins__，然后通过这个全局字典来获取os模块，之后就可以使用os模块的popen函数运行cat命令来获取flag.php文件内容了。 最终的payload为： ?tpl={{config.__class__.__init__.__globals__['os'].popen('cat /flag.php').read()}} 再通过浏览器发送带有payload的GET请求，就可以读取/root/flag.php中的flag了。 ### 回答3： 简单SSTI 1是一道基于SSTI漏洞的Web安全挑战题目，该题的难度属于初级。本题需要掌握一定的SSTI漏洞的相关知识和技巧，以及对模板中的变量注入点的识别和利用能力。 首先，我们尝试在输入框中输入简单的Python表达式，例如{{2+2}}，并提交请求，发现得到的响应结果为4，表明该网站存在SSTI漏洞。接着，我们可以构造一些特殊的表达式进行测试，例如{{123456789}}, {{2**100}}, {{'hello ' + 'world'}}, 发现均能得到正确的响应结果。 接着我们需要进行变量注入点的识别和利用，这里，我们可以通过利用flask框架中的特殊变量，例如request、g等来实现变量注入，例如{{config}}，可以获得flask的配置信息，{{request}}可以获得当前请求的一些信息。需要注意的是，在实战中，这些利用方式可能会受到服务器的限制，无法完全实现。 最后，我们需要尝试获取敏感信息或者升级我们的权限，例如{{''.__class__.mro()[1].__subclasses__()[71]('/etc/passwd').read()}}，可以获取到服务器上/etc/passwd文件的内容。 总之，简单的SSTI漏洞需要熟练掌握SSTI漏洞的相关知识和技巧，识别变量注入点并利用它们获取敏感信息和升级权限，可以通过CTF题目学习，提高自己的Web安全攻防能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是君倩

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值