【CodeForces472G】Design Tutorial: Increase the Constraints

最新推荐文章于 2019-10-05 21:02:19 发布
原创 最新推荐文章于 2019-10-05 21:02:19 发布 · 436 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种利用分块FFT技术优化字符串匹配问题的方法，通过将字符串分块并使用快速傅立叶变换（FFT）预处理，显著提高了查询效率。相较于bitset方法，此方案在时间复杂度上实现了突破。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

【题目链接】

【思路要点】

  • 先写一发bitset交上去试试，时间复杂度\(O(\frac{NQ}{w})\)，其中\(w=64\)，结果是T了，大概要12s才能跑出满数据。
  • 正解是分块FFT，令分块大小为\(Size\)，进行\(O(\frac{N}{Size})\)次FFT，处理出\(O(\frac{N}{Size})\)个\(T\)的后缀与\(S\)的每个长度为\(|T|\)的子串能够匹配的位数，询问时调用整块的结果，块内暴力计算。
  • 这样的时间复杂度是\(O(\frac{N^2LogN}{Size}+QSize)\)，取\(Size=\frac{N}{Q}\sqrt{QLogN}\)时，可以获得渐进意义下最优复杂度\(O(N\sqrt{QLogN})\)，笔者的程序取\(Size=8000\)，运行时间为6.2s。
  • 为什么这么慢呢？因为笔者每次会对0和1各做一次FFT，也就是说，FFT部分的常数被乘上了2。
  • 但实际上有一种更加高妙的做法来解决01匹配问题，我们令0为1，1为-1，然后FFT。那么两个字符如果匹配，得数为1，否则为-1，FFT后对结果数组进行简单处理就可以得到上面两次FFT一样的效果。
  • 笔者此时的程序取\(Size=7200\)，运行时间为4.5s。

【代码】

/*Clever Single FFT 4.5s approximately*/ 
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 524288;
const int REAL = 200005;
const int SIZE = 7200;
const int MAXK = 205;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
namespace FFT {
	const double pi = acos(-1);
	struct point {double x, y; };
	point operator + (point a, point b) {return (point) {a.x + b.x, a.y + b.y}; }
	point operator - (point a, point b) {return (point) {a.x - b.x, a.y - b.y}; }
	point operator * (point a, point b) {return (point) {a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x}; }
	point operator / (point a, double x) {return (point) {a.x / x, a.y / x}; }
	int N, Log, home[MAXN];
	point tmp[MAXN];
	void FFTinit() {
		for (int i = 0; i < N; i++) {
			int tmp = i, ans = 0;
			for (int j = 1; j <= Log; j++) {
				ans <<= 1;
				ans += tmp & 1;
				tmp >>= 1;
			}
			home[i] = ans;
		}
	}
	void FFT(point *a, int mode) {
		for (int i = 0; i < N; i++)
			if (home[i] < i) swap(a[i], a[home[i]]);
		for (int len = 2; len <= N; len <<= 1) {
			point delta = (point) {cos(2 * pi / len * mode), sin(2 * pi / len * mode)};
			for (int i = 0; i < N; i += len) {
				point now = (point) {1, 0};
				for (int j = i, k = i + len / 2; k < i + len; j++, k++) {
					point tmp = a[j];
					point tnp = a[k] * now;
					a[j] = tmp + tnp;
					a[k] = tmp - tnp;
					now = now * delta;
				}
			}
		}
		if (mode == -1) {
			for (int i = 0; i < N; i++)
				a[i] = a[i] / (4 * N);
		}
	}
	void times(double *a, double *b, double *c, int limit) {
		N = 1, Log = 0;
		while (N <= 2 * limit) {
			N <<= 1;
			Log++;
		}
		for (int i = 0; i < limit; i++)
			tmp[i] = (point) {a[i] + b[i], a[i] - b[i]};
		for (int i = limit; i < N; i++)
			tmp[i] = (point) {0, 0};
		FFTinit();
		FFT(tmp, 1);
		for (int i = 0; i < N; i++)
			tmp[i] = tmp[i] * tmp[i];
		FFT(tmp, -1);
		for (int i = 0; i < N; i++)
			c[i] = tmp[i].x;
	}
	void times(int *a, int *b, int *c, int limit) {
		N = 1, Log = 0;
		while (N <= 2 * limit) {
			N <<= 1;
			Log++;
		}
		for (int i = 0; i < limit; i++)
			tmp[i] = (point) {(double) (a[i] + b[i]), (double) (a[i] - b[i])};
		for (int i = limit; i < N; i++)
			tmp[i] = (point) {0, 0};
		FFTinit();
		FFT(tmp, 1);
		for (int i = 0; i < N; i++)
			tmp[i] = tmp[i] * tmp[i];
		FFT(tmp, -1);
		for (int i = 0; i < N; i++)
			c[i] = (int) (tmp[i].x + 0.5);
	}
	void times(long long *a, long long *b, long long *c, int limit) {
		N = 1, Log = 0;
		while (N <= 2 * limit) {
			N <<= 1;
			Log++;
		}
		for (int i = 0; i < limit; i++)
			tmp[i] = (point) {(double) (a[i] + b[i]), (double) (a[i] - b[i])};
		for (int i = limit; i < N; i++)
			tmp[i] = (point) {0, 0};
		FFTinit();
		FFT(tmp, 1);
		for (int i = 0; i < N; i++)
			tmp[i] = tmp[i] * tmp[i];
		FFT(tmp, -1);
		for (int i = 0; i < N; i++)
			c[i] = (long long) (tmp[i].x + 0.5);
	}
}
int ls, lt, tot;
char s[MAXN], t[MAXN];
int ans[MAXK][REAL];
int a[MAXN], b[MAXN], c[MAXN];
int index[MAXN], l[MAXN], r[MAXN];
int query(int ps, int pt) {
	int tans = 0;
	if (ps + SIZE >= ls || pt + SIZE >= lt) {
		while (ps < ls && pt < lt) tans += s[ps++] == t[pt++];
		return tans;
	}
	while (index[pt] == index[pt - 1]) tans += s[ps++] == t[pt++];
	tans += ans[index[pt]][ps];
	return tans;
}
int main() {
	scanf("\n%s\n%s", s, t);
	ls = strlen(s);
	lt = strlen(t);
	for (int i = 0; i < lt; i++) {
		if (i % SIZE == 0) l[++tot] = i;
		index[i] = tot; r[tot] = i;
	}
	for (int p = 1; p <= tot; p++) {
		memset(a, 0, sizeof(a));
		memset(b, 0, sizeof(b));
		for (int i = 0; i < ls; i++)
			if (s[i] == '0') a[i] = 1;
			else a[i] = -1;
		for (int i = l[p]; i < lt; i++)
			if (t[i] == '0') b[lt - 1 - i] = 1;
			else b[lt - 1 - i] = -1;
		int len = lt - l[p] - 1;
		int limit = max(ls, lt - l[p]);
		FFT::times(a, b, c, limit);
		for (int i = 0; i < ls; i++)
			ans[p][i] += (c[i + len] + len + 1 - max(0, i + len - ls + 1)) / 2;
	}
	int q; read(q);
	while (q--) {
		int ps, pt, len;
		read(ps), read(pt), read(len);
		writeln(len - query(ps, pt) + query(ps + len, pt + len));
	}
	return 0;
}
/*Simple FFT Twice 6.2s approximately*/ 
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 524288;
const int REAL = 200005;
const int SIZE = 8000;
const int MAXK = 205;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
namespace FFT {
	const double pi = acos(-1);
	struct point {double x, y; };
	point operator + (point a, point b) {return (point) {a.x + b.x, a.y + b.y}; }
	point operator - (point a, point b) {return (point) {a.x - b.x, a.y - b.y}; }
	point operator * (point a, point b) {return (point) {a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x}; }
	point operator / (point a, double x) {return (point) {a.x / x, a.y / x}; }
	int N, Log, home[MAXN];
	point tmp[MAXN];
	void FFTinit() {
		for (int i = 0; i < N; i++) {
			int tmp = i, ans = 0;
			for (int j = 1; j <= Log; j++) {
				ans <<= 1;
				ans += tmp & 1;
				tmp >>= 1;
			}
			home[i] = ans;
		}
	}
	void FFT(point *a, int mode) {
		for (int i = 0; i < N; i++)
			if (home[i] < i) swap(a[i], a[home[i]]);
		for (int len = 2; len <= N; len <<= 1) {
			point delta = (point) {cos(2 * pi / len * mode), sin(2 * pi / len * mode)};
			for (int i = 0; i < N; i += len) {
				point now = (point) {1, 0};
				for (int j = i, k = i + len / 2; k < i + len; j++, k++) {
					point tmp = a[j];
					point tnp = a[k] * now;
					a[j] = tmp + tnp;
					a[k] = tmp - tnp;
					now = now * delta;
				}
			}
		}
		if (mode == -1) {
			for (int i = 0; i < N; i++)
				a[i] = a[i] / (4 * N);
		}
	}
	void times(double *a, double *b, double *c, int limit) {
		N = 1, Log = 0;
		while (N <= 2 * limit) {
			N <<= 1;
			Log++;
		}
		for (int i = 0; i < limit; i++)
			tmp[i] = (point) {a[i] + b[i], a[i] - b[i]};
		for (int i = limit; i < N; i++)
			tmp[i] = (point) {0, 0};
		FFTinit();
		FFT(tmp, 1);
		for (int i = 0; i < N; i++)
			tmp[i] = tmp[i] * tmp[i];
		FFT(tmp, -1);
		for (int i = 0; i < N; i++)
			c[i] = tmp[i].x;
	}
	void times(int *a, int *b, int *c, int limit) {
		N = 1, Log = 0;
		while (N <= 2 * limit) {
			N <<= 1;
			Log++;
		}
		for (int i = 0; i < limit; i++)
			tmp[i] = (point) {(double) (a[i] + b[i]), (double) (a[i] - b[i])};
		for (int i = limit; i < N; i++)
			tmp[i] = (point) {0, 0};
		FFTinit();
		FFT(tmp, 1);
		for (int i = 0; i < N; i++)
			tmp[i] = tmp[i] * tmp[i];
		FFT(tmp, -1);
		for (int i = 0; i < N; i++)
			c[i] = (int) (tmp[i].x + 0.5);
	}
	void times(long long *a, long long *b, long long *c, int limit) {
		N = 1, Log = 0;
		while (N <= 2 * limit) {
			N <<= 1;
			Log++;
		}
		for (int i = 0; i < limit; i++)
			tmp[i] = (point) {(double) (a[i] + b[i]), (double) (a[i] - b[i])};
		for (int i = limit; i < N; i++)
			tmp[i] = (point) {0, 0};
		FFTinit();
		FFT(tmp, 1);
		for (int i = 0; i < N; i++)
			tmp[i] = tmp[i] * tmp[i];
		FFT(tmp, -1);
		for (int i = 0; i < N; i++)
			c[i] = (long long) (tmp[i].x + 0.5);
	}
}
int ls, lt, tot;
char s[MAXN], t[MAXN];
int ans[MAXK][REAL];
int a[MAXN], b[MAXN], c[MAXN];
int index[MAXN], l[MAXN], r[MAXN];
int query(int ps, int pt) {
	int tans = 0;
	if (ps + SIZE >= ls || pt + SIZE >= lt) {
		while (ps < ls && pt < lt) tans += s[ps++] == t[pt++];
		return tans;
	}
	while (index[pt] == index[pt - 1]) tans += s[ps++] == t[pt++];
	tans += ans[index[pt]][ps];
	return tans;
}
int main() {
	scanf("\n%s\n%s", s, t);
	ls = strlen(s);
	lt = strlen(t);
	for (int i = 0; i < lt; i++) {
		if (i % SIZE == 0) l[++tot] = i;
		index[i] = tot; r[tot] = i;
	}
	for (int p = 1; p <= tot; p++) {
		memset(a, 0, sizeof(a));
		memset(b, 0, sizeof(b));
		for (int i = 0; i < ls; i++)
			a[i] = s[i] == '0';
		for (int i = l[p]; i < lt; i++)
			b[lt - 1 - i] = t[i] == '0';
		int len = lt - l[p] - 1;
		int limit = max(ls, lt - l[p]);
		FFT::times(a, b, c, limit);
		for (int i = 0; i < ls; i++)
			ans[p][i] += c[i + len];
		memset(a, 0, sizeof(a));
		memset(b, 0, sizeof(b));
		for (int i = 0; i < ls; i++)
			a[i] = s[i] == '1';
		for (int i = l[p]; i < lt; i++)
			b[lt - 1 - i] = t[i] == '1';
		len = lt - l[p] - 1;
		limit = max(ls, lt - l[p]);
		FFT::times(a, b, c, limit);
		for (int i = 0; i < ls; i++)
			ans[p][i] += c[i + len];
	}
	int q; read(q);
	while (q--) {
		int ps, pt, len;
		read(ps), read(pt), read(len);
		writeln(len - query(ps, pt) + query(ps + len, pt + len));
	}
	return 0;
}
/*Bitset Version 12s approximately, TLE*/
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const int bit = 64; 
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
int ls, lt;
char s[MAXN], t[MAXN];
bitset <bit> masks[MAXN], maskt[MAXN];
int main() {
	scanf("\n%s\n%s", s, t);
	ls = strlen(s);
	lt = strlen(t);
	for (int i = 0; i <= ls - bit; i++)
	for (int j = 0; j < bit; j++)
		if (s[i + j] == '1') masks[i].set(j);
		else masks[i].reset(j);
	for (int i = 0; i <= lt - bit; i++)
	for (int j = 0; j < bit; j++)
		if (t[i + j] == '1') maskt[i].set(j);
		else maskt[i].reset(j);
	int q; read(q);
	while (q--) {
		register int ps, pt, len, ans = 0;
		read(ps), read(pt), read(len);
		while (len >= bit) {
			ans += (masks[ps] ^ maskt[pt]).count();
			ps += bit, pt += bit, len -= bit;
		}
		for (int i = 0; i < len; i++)
			ans += s[ps + i] != t[pt + i];
		writeln(ans);
	}
	return 0;
}


CodeForces 472D Design Tutorial: Inverse the Problem (最小生成树+lca)
退役的铜牌狗
05-15 625
There is an easy way to obtain a new task from an old one called “Inverse the problem”: we give an output of the original task, and ask to generate an input, such that solution to the original problem
Codeforces 472G Design Tutorial: Increase the Constraints(分块+FFT)
yamiedie_
03-15 640
#include #include #include #include using namespace std; #define N 550020 #define LL long long #define MOD 1000000007 #define K 3 #define G 3 const int B = 6000; int n, m; char s[N], t[N]; in
【CF472G】Design Tutorial: Increase the Constraints
weixin_30565199的博客
07-31 198
Description 　　 　　给出两个01序列\(A\)和\(B\) 　　 　　要求回答\(q\)个询问每次询问\(A\)和\(B\)中两个长度为\(len\)的子串的哈明距离 　　 ​　　 哈明距离的值即有多少个位置不相等 　　 ​　　 \(1 \le |A|,|B| \le 2*10^5\) 　　 ​　　\(1 \le q \le 4*10^5\) 　　　　 ​　　 保证输入合法，序列下标...
CF 472 G Design Tutorial: Increase the Constraints - bitset - 分块
Mys_C_K的博客
07-30 259
题目大意：给定两个01字符串A和B，多次A和B的两个子串有多少位置不一样。 考虑分块，设ans(a, b)表示A的第a块和B从b开始的答案，用bitset优化即可。 #include&lt;iostream&gt; #include&lt;cstring&gt; #include&lt;cstdio&gt; #include&lt;algorithm&gt; #include&lt;bit...
Codeforces Round #270 G. Design Tutorial: Increase the Constraints 分块+FFT
huantwofat
08-11 662
我们如果要求两个串的哈密顿距离我们可以这样把第二个串反向，然后字母为1的地方系数为1，字母为0的系数为-1，所以我们可以算出x-y=a[n-1](x是相同的点数，y是不同的点数)有因为x+y=n所以y=(n-a[n-1])/2，所以我们可以用多项式求出a[n-1]即可，这可以用FFT实现，然后对于原题我们只需要把A分块，对于每块与B串FFT一下保存一下答案即可。 注意sqrt分块会超时，因为FF
codeforces-stats-analyzer:可以分析用户个人资料
05-16
codeforces-stats-analyzer 是一个基于JavaScript的工具，主要用于分析Codeforces平台上的用户个人资料。Codeforces是一个著名的在线编程竞赛和练习网站，吸引了众多程序员参与挑战，提升编程技能。这个工具可以帮助...
Codeforces-Android-App:此应用程序是使用官方 Codeforces API 开发的。 当前仅支持用户信息详细信息。 我会尽快添加更多功能
06-22
Codeforces是一个知名的在线编程竞赛平台，它吸引了众多程序员参与各种算法比赛。为了提供更好的移动体验，有人开发了Codeforces的Android应用。这个应用是利用Codeforces的官方API来获取和展示数据的，使得用户能够...
谷歌师兄的leetcode刷题笔记-Codeforces-Problems-Solutions:Java中一些Codeforces问题的解决方
06-30
Codeforces 问题的解决方案 CF-A 水平问题 问题的排序基于 Dr.Mostafa Saad 的工作表： # 问题 代码 CF677-D2-A 万尼亚和篱笆 CF734-D2-A 安东和丹尼克 CF791-D2-A 熊大哥 CF231-D2-A 团队 CF263-D2-A 美丽的矩阵 ...
codeforces-problem-filter:一个简单的脚本，用于从Codeforce问题集中获取具有给定标签的特定类型的问题
05-19
Codeforces问题过滤器 我一直想通过以下方式练习来自代码部队的问题： 获得5个具有标签dp的问题，所有问题都应为问题A 因此，此脚本现在为您获取特定标签和索引的所有问题，并将它们以pdf格式存储在自动在仓库中...
cf 472G Design Tutorial: Increase the Constraints 分块+压位/FFT
weixin_30869099的博客
02-25 157
题目大意 给出两个\(01\)序列\(A\)和\(B\) 哈明距离定义为两个长度相同的序列中，有多少个对应位置上的数字不一样 "00111" 和 "10101"的距离为2 \(Q\)次询问，每次询问给出\(p_1,p_2,len\) 求\(a{p_1},a{p_1+1}...a_{p_1+len-1}\) 和 \(b_{p_1},b_{p_1+1}...b_{p_1+len-1}\)两个子串的哈明...
Codeforces 460E Roland and Rose(暴力)
weixin_34255793的博客
04-25 173
题目链接：Codeforces 460E Roland and Rose 题目大意：在以原点为圆心，半径为R的局域内选择N个整数点，使得N个点中两两距离的平方和最大。 解题思路：R最大为30。那么事实上距离圆心距离最大的整数点只是12个最多，直接暴力枚举。 #include &lt;cstdio&gt; #include &lt;cstring&gt; #include ...
codeforces 123D
guoshiyuan484的博客
01-22 415
单调栈+后缀数组 此题看的角度是，先把后缀进行排序，然后每个后缀里的子串，从前面开始数 比如aasss 其中一个后缀是 asss 那么字串有 a as ass asss 明白了这个再想法用高度数组。 如果还不明白一般是不太会单调栈，建议去bzoj切几道单调栈再回来看 #include #include #include using namespace std; typedef l
Codeforces 623E Transforming Sequence (分治+FFT)
yamiedie_
03-15 1083
#include #include #include #include using namespace std; #define N 200020 #define LL long long #define MOD 1000000007 #define K 3 #define G 3 // 1000000000000000000 30000 int m[] = {1004535809,
gym102059 Electronic Circuit
binarycopycode
10-05 212
https://codeforces.com/gym/102059/problem/E 被签到博弈关了一下午，队内博弈选手没来，sg函数都是我18年1月学的东西了，早忘光了。。。。 结果看了这题发现全机房都做出来了我也不会做，菜哭.jpg 很简单的思路，就是度为二的点可以被去掉，a-u-b可以等价为a-b，不断重复这个过程到最后只剩一对点和一条边或者不剩点就结束了，用set对重复边去重，重边...
GYM 102059 G Fascination Street
swqeaaa的博客
09-25 385
G Fascination Street 给出一串n(2e5)个灯, 每个灯点亮可以照到相邻三个位置, 每个灯点亮都有不同的花费, 现在可以交换k(9)次灯的位置, 求把所有n个位置都照到的最小花费. 交换的肯定是一个亮的灯和一个灭的灯, 不然是没有意义的.(即, 将一个花费低的灯点亮, 根花费高, 未点亮的灯交换位置.) 对于每个位置i, 保存最后两个灯(i-1,i)是否点亮(注意是点亮, 不是...
codeforces gym102059 Fake Plastic Trees 构造
xiji333的博客
10-04 660
https://codeforces.com/gym/102059/problem/F 题目大意：让你建造一棵树，使得它有nnn个叶子节点，而且需要满足对于每个节点，它的左子树大小等于右子树大小，或者左子树大小比右边大111。每次你构造一棵树，你可以选择之前构造过的树作为它的儿子。 现在让你构造不超过125棵树，满足上诉条件。输出的方式是：输出VVV，表示构造的树的数目。 接下来VVV行，每行两...
CodeForces 472D Design Tutorial: Inverse the Problem (最小生成树)
Shion的专栏
01-06 993
题意：给出一个树中每两个节点的距离，问是否能构成一颗加权树。 思路： 以下几种情况可以直接输出NO：arr[i][i]!=0, arr[i][j] == 0(i != j), arr[i][j]!=arr[j][i]. 否则，每次选最小的边，加入生成树，最后在算一遍节点两两之间的距离，如果与输入矩阵不同则输出NO。 节点两两距离dist[i][j] = dist[root][i] + di
【CodeForces】CodeForces Round #477 (Div. 1 + Div. 2) 题解
cz_xuyixuan的博客
05-07 1706
【比赛链接】Div. 1Div. 2【题解链接】点击打开链接【Div.2 A】Mind the Gap【思路要点】从小到大枚举答案，检查合法性。时间复杂度\(O(Ans*N)\)。【代码】#include&lt;bits/stdc++.h&gt; using namespace std; const int MAXN = 100005; template &lt;typename T&gt; vo...
CodeForces蒙文浏览器扩展发布：本地化CodeForces内容
CodeForces是一个在线平台，主要面向程序员和编程爱好者，提供编程竞赛、问题集、在线评测等功能，是程序员刷题、练习算法与数据结构的热门网站。本地化扩展允许用户更方便地在这个平台上使用蒙古语。 3. **本地化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值