程序员编程艺术学习笔记（四）现场编写类似strstr/strcpy/strpbrk的函数

最新推荐文章于 2022-08-02 21:33:16 发布
最新推荐文章于 2022-08-02 21:33:16 发布
阅读量804 收藏 1
点赞数
分类专栏： 编程艺术java版 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gloria0610/article/details/26453423
版权

程序员编程艺术原文出自大神:v_JULY_v  地址:http://blog.csdn.net/v_july_v/article/category/784066

c++实现.敬请膜拜。

字符串问题虽基础，变化却是令人发指=—=，随便改改就能让人纠结半天。。继续砸瓷实基础，基础，基础。

原文C++实现，现将自己实现的java版本记录如下，不定期更新，自我监督，自我监督。


跳过了第三章的排序内容，因为需要去了解一些细节

继续提升编程能力和习惯，先把之后的实现。


第一节、字符串查找
1.1题目描述：
给定一个字符串A，要求在A中查找一个子串B。
如A="ABCDF"，要你在A中查找子串B=“CD”。

常用的两种方式，暴力破解法和KMP算法。

KMP算法要解决的问题就是在字符串（也叫主串）中的模式（pattern）定位问题。说简单点就是我们平时常说的关键字搜索。模式串就是关键字（接下来称它为P），如果它在一个主串（接下来称为T）中出现，就返回它的具体位置，否则返回-1（常用手段）。

 

首先，对于这个问题有一个很单纯的想法：从左到右一个个匹配，如果这个过程中有某个字符不匹配，就跳回去，将模式串向右移动一位。这有什么难的？

我们可以这样初始化：

 

之后我们只需要比较i指针指向的字符和j指针指向的字符是否一致。如果一致就都向后移动，如果不一致，如下图：

 

 

A和E不相等，那就把i指针移回第1位（假设下标从0开始），j移动到模式串的第0位，然后又重新开始这个步骤：

 


暴力破解法，时间复杂度O（n*m）【我们知道实际应用中这种方式消耗就很高了】

(注:在代码风格异常判断的时候，多看几种代码，养成采众家之长的习惯。干净漂亮规整的代码，对后期发展的好处不是一点噢)

主体代码如下：

public class StrStr {
	public static void main(String args[]){
		String str1="ABCDEFGHIJKLMN";
		String str2="GHI";
		String str3="WEREIJG";
		System.out.println(getInNum(str1,str2));
		
		
	}
	public static int getInNum(String str1,String str2){
		int num=0;
		
		if(str1==null||str2==null){
			return -1;
		}
		char[] a=str1.toCharArray();
		char[] b=str2.toCharArray();
		if(a.length<b.length){
			return -1;
		}
	
		int i=0;//主串位置
		int j=0;//子串位置
		
		while(i<a.length&&j<b.length)	{	
		if(a[i]==b[j]){// 当两个字符相同，就比较下一个
			i++;
			j++;
		}else{
			i=i-j+1;// 一旦不匹配，i后退
			j=0;// j归0
		}
		}
		//开始对于循环外判断有疑问，debug发现j已经不小于b.length了 循环被跳出
		if(j==b.length){
			return i-j;
		}
		else{
			return -1;
		}
	}
	
	
	
	//个人倾向第一种方式 这个是原作者方式，个人感觉逻辑不够清晰 返回的i+1也值得商榷
	public static int getInNum2(String str1,String str2){
		int num=0;
		
		if(str1==null||str2==null){
			return -1;
		}
		char[] a=str1.toCharArray();
		char[] b=str2.toCharArray();
		if(a.length<b.length){
			return -1;
		}
		int i,j;
		for(i=0;i<a.length;i++){
			for(j=0;j<b.length;j++){
				if(a[i+j]!=b[j]){
					break;
				}
				
			}
			if(j==b.length){
				return i+1;
			}
				
		}
		return -1;
		
	}
}


KMP方法

KMP算法看了很多，每一个都挺详细但是清晰的不多，下边列举几种说明，也许单独看某个说明不好理解，结合起来看，就可以明白位移量的关键原理了。


http://billhoo.blog.51cto.com/2337751/411486

【KMP算法思想详述与实现】
 
        前面提到，KMP算法通过一个“有用信息”可以知道目标串中下一个字符是否有必要被检测，这个“有用信息”就是用所谓的“前缀函数（一般数据结构书中的next函数）”来存储的。
        这个函数能够反映出现失配情况时，系统应该跳过多少无用字符（也即模式串应该向右滑动多长距离）而进行下一次检测，在上例中，这个距离为4.
        总的来讲，KMP算法有2个难点：
              一是这个前缀函数的求法。
              二是在得到前缀函数之后，怎么运用这个函数所反映的有效信息避免不必要的检测。
下面分为两个板块分别详述：
 
 
【前缀函数的引入及实现】
 
【前缀函数的引入】
        对于前缀函数，先要理解前缀是什么：
        简单地说，如字符串A = "abcde"        B = "ab"
        那么就称字符串B为A的前缀，记为B ⊏ A(注意那不是"包含于"，Bill把它读作B前缀于A)，说句题外话——"⊏"这个符号很形象嘛，封了口的这面相当于头，在头前面的就是前缀了。
        同理可知 C = "e","de" 等都是 A 的后缀，以为C ⊐ A（Bill把它读作C后缀于A）
      
理解了什么是前、后缀，就来看看什么是前缀函数：
        在这里不打算引用过多的理论来说明，直接引入实例会比较容易理解，看如下示例：
 
 
      (下述字符若带下标，则对应于图中画圈字符)
      这里模式串 P = “ababaca”,在匹配了 q=5 个字符后失配，因此，下一步就是要考虑将P向右移多少位进行新的一轮匹配检测。传统模式中，直接将P右移1位，也就是将P的首字符'a'去和目标串的'b'字符进行检测，这明显是多余的。通过我们肉眼的观察，可以很简单的知道应该将模式串P右移到下图'a3'处再开始新一轮的检测，直接跳过肯定不匹配的字符'b'，那么我们“肉眼”观察的这一结果怎么把它用语言表示出来呢？
 
 

     我们的观察过程是这样的：
          P的前缀"ab"中'a' != 'b'，又因该前缀已经匹配了T中对应的"ab"，因此，该前缀的字符'a1'肯定不会和T中对应的字串"ab"中的'b'匹配，也就是将P向右滑动一个位移是无意义的。
          接下来考察P的前缀"aba"，发现该前缀自身的前缀'a1'与自身后缀'a2'相等，"a1 b a2" 已经匹配了T中的"a b a3"，因此有 'a2' == 'a3', 故得到 'a1' == 'a3'......
          利用此思想，可推知在已经匹配 q=5 个字符的情况下，将P向右移 当且仅当 2个位移时，才能满足既没有冗余(如把'a'去和'b'比较)，又不会丢失(如把'a1' 直接与 'a4' 开始比较，则丢失了与'a3'的比较)。
          而前缀函数就是这样一种函数，它决定了q与位移的一一对应关系，通过它就可以间接地求得位移s。
   
     通过对各种模式串进行上述分析(大家可以自己多写几个模式串出来自己分析理解)，发现给定一个匹配字符数 q ，则唯一对应一个有效位移，如上述q=5,则对应位移为2.
     这就形成了一一对应关系，而这种唯一的关系就是由前缀函数决定的。
     这到底是怎样的一种关系呢？
     通过对诸多模式串实例的研究，我们会找到一个规律（规律的证明及引理详见《算法导论(第二版)》）。
     上例中，P 已经匹配的字符串为"ababa",那么这个字符串中，满足既是自身真后缀(即不等于自身的后缀)，又是自身最长前缀的字符串为"aba"，我们设这个特殊字串的长度为L，显然，L = 3. 故我们要求的 s = q - L = 5 - 3 = 2 ，满足前述分析。
   
     根据这个规律，即可得到我们要求的有效位移s，等于已经匹配的字符数 q 减去长度 L。
     即 s = q - L
     因为这个长度 L 与 q 一一对应，决定于q，因此用一函数来表达这一关系非常恰当，这就是所谓的前缀函数了。
     因为已经分析得到该关系为一一对应关系，因此用数组来表示该函数是比较恰当的，以数组的下标表示已经匹配的字符数 q，以下标对应的数据存储 L。

了解了前缀函数原理，也就是说我们可以计算出位移量，那么后续移位的形式就和单步一样了。

所以KMP算法的关键在于，确定next的位置.

next的确定就是找到已经匹配的字符串既是自身真后缀，又是自身最长前缀的字符串长度 用总长度减之，就是我们指针要挪的next位了。

所以问题转化为，找一个字符串中，相等的最长前缀与自身真后缀。和用next位再次对比的事情。

实现代码如下:

public class KMP {
        public static void main(String args[]){
              String str1= "abcdeababcdqqabcdeabc";
              String str2= "abcdeabc";
              String str3="abcd";
              System. out.println(strIn(str1,str2));
              System. out.println(kmp(str1,str2));
       }
       
        public static int strIn(String str1,String str2){
               char[] a=str1.toCharArray();
               char[] b=str2.toCharArray();
               int i=0;
               int j=0;
               while(i<a.length &&j<b.length){
                      if(a[i]==b[j]){
                           i++;
                           j++;
                     } else{
                           i=i-j+1;
                           j=0;
                     }
              } if(j==b.length ){
                      return i-j;
              }
              
               return -1;
              
       }
       
        public static int kmp(String str1,String str2){
               char[] a=str1.toCharArray();
               char[] b=str2.toCharArray();
               int[] next=getNext(b);
               int j=0;
               for(int i=0;i<a.length;i++){
                      //当找到第一个匹配字符时，即j>0，且后续不匹配，才会执行这个循环，去找合适的回退位置
                      while(j>0&&b[j]!=a[i]){
                            //j退回合适的回退位置
                           j=next[j-1];
                     }
                      //如果匹配，j++
                      if(b[j]==a[i]){
                           j++;
                     }
                      if(j==b.length ){
                            //return i-j;
                           System. out.println(i-j);
                            //j=next[j-1];
                            return i-j;
                     }
                     
              }
               return -1;
              
       }
       
        public static int[] getNext(char[] b){
               int next[]=new int[b.length];
              next[0]=0;
               int j=0;
               //为何i=1?对比
               for(int i=1;i<b.length;i++){
                      //第一个匹配之后
                      while(j>0&&b[j]!=b[i]){
                           j=next[j];
                     }
                      if(b[j]==b[i]){
                           j++;
                     }
                     next[i]=j;
              }
               return next;
       }
}


 

 

public class KMP {

    /**
     * 对子串加以预处理，从而找到匹配失败时子串回退的位置 找到匹配失败时的最合适的回退位置，而不是回退到子串的第一个字符，即可提高查找的效率
     * 因此为了找到这个合适的位置，先对子串预处理，从而得到一个回退位置的数组
     * @param B，待查找子串的char数组
     * @return
     */

    public static int[] preProcess(char[] b) {
      int size = b.length;
       int[] P = new int[size];
      P[0] = 0;
      int j = 0;
      // 每循环一次，就会找到一个回退位置
      for (int i = 1; i < size; i++) {
          // 当找到第一个匹配的字符时，即j>0时才会执行这个循环
          // 或者说p2中的j++会在p1之前执行（限于第一次执行的条件下）
          // p1
          while (j > 0 && b[j] != b[i]) {
             j = P[j];
          }
          // p2，由此可以看出，只有当子串中含有重复字符时，回退的位置才会被优化
          if (b[j] == b[i]) {
              j++;
          }
          // 找到一个回退位置j，把其放入P[i]中
          P[i] = j;
      }
      return P;
    }

 

    /**
     * KMP实现
     *
     * @param parStr
     * @param subStr
     * @return
     */

    public static void kmp(String parStr, String subStr) {
      int subSize = subStr.length();
      int parSize = parStr.length();
      char[] b = subStr.toCharArray();
      char[] a = parStr.toCharArray();
      int[] P = preProcess(b);
      int j = 0;
      int k = 0;
      for (int i = 0; i < parSize; i++) {
          // 当找到第一个匹配的字符时，即j>0时才会执行这个循环
          // 或者说p2中的j++会在p1之前执行（限于第一次执行的条件下）
          // p1
          while (j > 0 && b[j] != a[i]) {
              // 找到合适的回退位置
              j = P[j - 1];
          }
          // p2 找到一个匹配的字符
          if (b[j] == a[i]) {
              j++;
          }
          // 输出匹配结果，并且让比较继续下去
          if (j == subSize) {
            j = P[j - 1];
              k++;
              System.out.printf("Find subString '%s' at %d\n", subStr, i
                   - subSize + 1);
          }
      }
      System.out.printf("Totally found %d times for '%s'.\n\n", k, subStr);
    }

 

    public static void main(String[] args) {
      // 回退位置数组为P[0, 0, 0, 0, 0, 0]
     // kmp("abcdeg, abcdeh, abcdef!这个会匹配1次", "abcdef");
      // 回退位置数组为P[0, 0, 1, 2, 3, 4]
      kmp("Test ititi ititit! Test ititit!这个会匹配2次", "ititit");
      // 回退位置数组为P[0, 0, 0]
      kmp("测试汉字的匹配，张三。这个会匹配1次", "张三");
      // 回退位置数组为P[0, 0, 0, 1, 2, 3, 4, 5, 6]
      kmp("这个会匹配0次", "it1it1it1");
    }

}


-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

/**
 * KMP算法的实现
 * @author dfeng
 *
 */
public class KMPAlgorithm {

	/**
	 * 判断是否匹配
	 * @param target 目标文本串
	 * @param mode 模式串
	 * @return 匹配结果
	 */
	public static int matchString(String target, String mode) {
		//为了和算法保持一致，使index从1开始，增加一前缀
		String newTarget = "x" + target; 
		String newMode = 'x' + mode;
		
		int[] K = calculateK(mode);
		
		int i = 1;
		int j = 1;
		while(i <= target.length() && j <= mode.length()) {
			if (j == 0 || newTarget.charAt(i) == newMode.charAt(j)) {
				i++;
				j++;
			} else {
				j = K[j];
			}
		}
		
		if (j > mode.length()) {
			return j;
		}
		return -1;
	}
	
	/*
	 * 计算K值
	 */
	private static int[] calculateK(String mode) {
		//为了和算法保持一致，使index从1开始，增加一前缀
		String newMode = "x" + mode;
		int[] K = new int[newMode.length()];
		int i = 1;
		K[1] = 0;
		int j = 0;
		
		while(i < mode.length()) {
			if (j == 0 || newMode.charAt(i) == newMode.charAt(j)){
				i++;
				j++;
				K[i] = j;
			} else {
 				j = K[j];
			}
		}
		
		return K;
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String a = "bcabcabcabbcabcabcabcab";
		String b = "bcabcabcabc";//"ababbaaba";//
		System.out.println(KMPAlgorithm.matchString(a, b));

	}

}




---------------------------------------------------------------------------------------------------------------------------------------------

参考资料:

http://www.cnblogs.com/yjiyjige/p/3263858.html

http://billhoo.blog.51cto.com/2337751/411486

http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html



1.2、题目描述

在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b。 

代码则可以如下编写：

public class test01 {
     //此方法用到了indexOf(char,startIndex)
     public static void main(String[] args){
          String string="abcdace";
          for(int i=0;i<string.length();i++){
               char c = string.charAt(i);
               if(string.indexOf(c, i+1) == -1){
                    System.out.println(c);
                    break;
               }              
          }
     }
}
---------------------------------------------------------------------------------------
public class test01 {
     //此处用到indexOf和lastIndexOf
     public static void main(String[] args){
          String string="abcdace";
          for(int i=0;i<string.length();i++){
               char c = string.charAt(i);
System.out.println(string.indexOf(c));
System.out.println(string.lastIndexOf(c));
               if(string.indexOf(c) == string.lastIndexOf(c)){
                    System.out.println(c);
                    break;
               }
          }
     }
}




找出现多次的字符
-------------------------------------------------------------------------------------
public class test01 {
    
     public static void main(String[] args){
          String string="abcdace";
          for(int i=0;i<string.length();i++){
               char c = string.charAt(i);
               if(string.indexOf(c, i+1) != -1){
                    System.out.println(c);
                    break;
               }
          }
     }
}
-------------------------------------------------------------------------------------
public class test01 {
     //此处用到indexOf和lastIndexOf
     public static void main(String[] args){
          String string="abcdace";
          for(int i=0;i<string.length();i++){
               char c = string.charAt(i);
               if(string.indexOf(c) != string.lastIndexOf(c)){
                    System.out.println(c);
                    break;
               }
          }
     }
}


------------------------------------------------------------------------------------
需改进的hashmap方法

import java.util.HashMap;
import java.util.Scanner;


public class StringFirst {
public static void main(String args[]){
       Scanner scanner=new Scanner(System. in);
       System. out.print("请输入字符串:" );
       String str=scanner.nextLine();
       System. out.print(str);
        char []strArray=str.toCharArray();
       HashMap<Character,Integer> map= new HashMap<Character,Integer>();
        for(int i=0;i<strArray.length;i++){
               if(map.containsKey(strArray[i]))
              {
                     map.put(strArray[i],map.get(strArray[i])+1);
              }
        else{
              map.put(strArray[i], 1);
       }}
       
       System. out.println(map);
       
        for(int i=0;i<strArray.length;i++){
               if(map.get(strArray[i])==1){
                     
                      
                     System. out.print("第一个出现一次的字符是" +strArray[i]);
                      break;
              }
              
       }
       
}
}

第二节、字符串拷贝
题目描述：
要求实现库函数strcpy，
原型声明：extern char *strcpy(char *dest,char *src); 
功能：把src所指由NULL结束的字符串复制到dest所指的数组中。 　
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。 　
返回指向dest的指针。

这个有点迷糊，不太理解此题意义。。因为实在是简单，是否题目理解错误。 

public class StrCopy {
	public static void main(String args[]){
		String str="ashdkiwekfsgmnklrger";
		
		String str1=strCopy(str);
		System.out.println(str1);
	}
	
	public static String strCopy(String str){
		char[] a=str.toCharArray();
		char[] b=new char[a.length];
		for(int i=0;i<a.length;i++){
			b[i]=a[i];
		}
		return new String(b);
	}
}


猫小呆
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java程序员要知道的C/C++函数
01-21
（1）函数原型：extern char strstr(char *haystack，char *needle); 　用法：#include 　功能：从字符串haystack中寻找needle第一次出现的位置（不比较结束符NULL)返回指向第一次出现needle位置的指针，如果没有...
c++中strstr函数的几种实现方法
明月松间照，清泉石上流！
10-04 5705
函数说明： 包含文件：string.h 函数名: strstr 函数原型：extern char *strstr(char *str1, char *str2); 功能：从字符串str1中查找是否有字符串str2， 如果有，从str1中的str2位置起，返回str1的指针，如果没有，返回null。 返回值：返回该位置的指针，如找不到，返回空指针。
c语言-查找字符串子串（类似strstr()函数）
qq_66923215的博客
08-02 1914
c语言-查找字符串字串（类似strstr()函数）
程序员编程艺术：第四章、现场编写类似strstr/strcpy/strpbrk的函数
热门推荐
结构之法 算法之道
05-13 4万+
第四章、现场编写类似strstr/strcpy/strpbrk的函数     作者：July。    说明： 如果在博客中代码使用了\n，csdn blog系统将会自动回给我变成/n。据后续验证，可能是原来旧blog版本的bug，新版已不存在此问题。至于，本文代码，日后统一修正。July、2012.05.02。      微博：http://weibo.com/julyweibo  。    出处
memmem()和strstr()函数
koozxcv的博客
11-09 9310
memmem是一个C库函数，用于在一块内存中寻找匹配另一块内存的内容的第一个位置，这个问题的起因是在内核漏洞exploit中有使用到。 首先是一个比较直观的myMemmem（如果严格一点，长度应该是size_t型，而且要先判断alen和blen的大小关系，以及是否为正整数，这里都省了） int myMemmem(char * a, int alen, char * b, int blen)
strstr和strcpy函数实现
08-02
strstr函数和strcpy函数的简单实现
php字符串函数学习之strstr()
12-18
strrchr()函数与strstr()类似，但它查找的是字符串的最后一次出现，并返回从该位置到字符串结尾的部分。如果未找到，也会返回false。其语法为`strrchr(haystack, char)`。例如： ```php $str = "Hello world!Hello ...
php学习笔记之mb_strstr的基本使用
10-18
在PHP编程中，`mb_strstr()` 是一个非常实用的多字节字符串处理函数，尤其在处理包含多种语言或特殊字符的字符串时。与常规的 `strstr()` 函数不同，`mb_strstr()` 支持多种字符编码，如UTF-8，GBK等，从而能够正确...
有意思的字符串查找函数strchr,strrchr,strstr,strrstr
微风
05-06 2万+
每日一编程，希望再接再厉！
类似strstr/strcpy/strpbrk函数的实现
expleeve
04-13 2302
第一节、字符串查找 1.1题目描述： 给定一个字符串A，要求在A中查找一个子串B。 如A="ABCDF"，要你在A中查找子串B=“CD”。 分析：比较简单，相当于实现strstr库函数，主体代码如下： //在字符串中查找指定字符串的第一次出现，不能找到则返回-1 int strstr(char *string, char *substring) {
有趣的字符查找函数模拟strstr和strrstr,strchr和strrchr
qq_29503203的博客
05-07 1174
标准库中存在许多函数，它们用各种不同的方法查找字符串，像strstr,strchr和strrchr等等.这些各种各样的工具给了c程序员很大的灵活性，为了更好地了解它们的作用，下来我们将它们一一模拟实现。
库函数strstr的实现，比较库函数strstr和strchr。
Yinghuhu333333的博客
11-24 1052
strstr(str,str1):该函数用来判断字符串str1是否是str的子串。如果是，就返回str1在str中首次出现的地址；如果不是，返回NULL；strchr:用来查找字符串中首次出现某字符的位置；可以看出strstr查找的是字符串，strchr查找的是字符；字符和字符串的区别是：字符串以‘\0’结束，字符串可以包含多个字符；而字符就是单个字符。下面是实现strstr库函数的具体的代码：#...
现场编写类似strstr/strcpy/strpbrk的函数
继续微笑lsj
08-10 1222
第一节、字符串查找 1.1题目描述： 给定一个字符串A，要求在A中查找一个子串B。 如A="ABCDF"，要你在A中查找子串B=“CD”。 分析：比较简单，相当于实现strstr库函数，主体代码如下： //在字符串中查找指定字符串的第一次出现，不能找到则返回-1       int strstr(char *string, char *substring)
C语言:自定义一个查找字串的功能函数，类似于<string.h>中的strstr()
weixin_34072159的博客
10-10 674
//自定义一个字符串字串查找标准库函数strstr() #include<stdio.h> #include<string.h> char* myStrstr(char *str1,char *str2); int main() { 　　　　char *str1 = "hello worl world ld"; 　　　　char...
飞机大战系列 Space War1.0（免费，开源）
07-14
飞机大战系列 Space War1.0（免费，开源）
基于Hadoop的文件词频统计的实现（大数据技术课程设计）
07-14
使用Hadoop大数据架构体系中的HDFS、HBase以及Spark软件，完成大数据处理的典型案例：文件词频统计的实现。
湖科大计算机网络视频笔记，跟着视频系统学了一遍的记录
最新发布
07-14
视频链接：https://www.bilibili.com/video/BV1c4411d7jb/，适用于考研后期查缺补漏和前期确定复习方向、期末考和课前预习。做成PDF形式便于查阅和在iPad上查看。
编写strstr函数
11-27
strstr函数是C语言中的一个字符串处理函数，用于在一个字符串中查找另一个字符串的出现位置。其函数原型为： ```c char *strstr(const char *str1, const char *str2); ``` 其中，str1为要查找的字符串，str2为要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值