Hankerrank World CodeSprint #4 Gridland Provinces （字符串双hash ）

最新推荐文章于 2024-07-12 22:00:07 发布
最新推荐文章于 2024-07-12 22:00:07 发布
阅读量802 收藏
点赞数
分类专栏： HASH／字符串hash
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kalilili/article/details/51770110
版权

题目链接：https://www.hackerrank.com/contests/june-world-codesprint/challenges/gridland-provinces

题意：一个两行n列的字符格子，一个人必须走个哈密顿路径，任选起始和结束位置，最后求走出的字符串有多个不同的。

n<=1000


Observe that since the knight always completes his journey in minimum total time, he never visits the same city twice. In other words, the path formed by the Knight is a  path.


Suppose the knight starts his journey from cell , visits every cell to its  and comes to cell , then visits cell  and every cell to its  to cell . Now there are two possible options for the knight if he wishes to visit each cell  .


  • He can move  to cell , visiting all cells in between, and then go up to cell . From there visit all cells to its  until it reaches cell  thereby completing the tour.


  • Otherwise the knight can move to cell  followed by a move to cell . In this case there are again two possible options for the knight. Move from cell  to cell  followed by a move to cell  and have two choices again. Or visit all cells to its , move  and visit all remaining cells to its .


Note that the knight can start from cell  instead of cell . Also, the knight can start from column , visit every cell to its , move down/up and visit every cell to its  until it reaches column  again and repeat the same procedure with two choices as elaborated before. So we need to handle these cases as well with a similar strategy as described.


There are  different values for . For each value of , the simulation described above can be done in . The hash value of the final string can be calculated in  after some pre-processing. The number of   possible is then the number of    found overall which can be easily maintained with a hashset or a sorted array to remove duplicates. Overall complexity is  with a sorted array or ,  with a hashset.


和官方题解思路一样，因为可以DP求出不同串的hash值，只需要O（1），所以一共有O(N* N)个串，最后std::unique()去重一下就好了。

吐槽一下，数据真强啊，单hash被卡了，双hash第一次 写，两个素数模数取的不好也会被卡，我取的1e9+7和1e9+9


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <iostream>
#include <string>
#include <cmath>
#include <set>
#include <map>
using namespace std;

#define REP(i, a, b) for (int i = (a), i##_end_ = (b); i < i##_end_; ++i)
#define MP make_pair
#define PB push_back
#define SZ(x) (int((x).size()))
#define ALL(x) (x).begin(), (x).end()
#define X first
#define Y second
template<typename T> inline bool chkmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
template<typename T> inline bool chkmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }

typedef long long LL;
typedef pair<LL, LL> pii;
const int oo = 0x3f3f3f3f;

const int N = 600 * 4 + 10;
pii h[N];
int top;
LL mp[N * N * 4];
int all;
char s[2][N];
const int MOD = 1e9 + 7;
const int MOD2 = 1e9 + 9;
const LL BASE = 26;
pair<LL, LL> p[N];

int main() {
	p[0].X = 1;
	for(int i = 1; i <= N - 10; i ++) p[i].X = p[i - 1].X * BASE % MOD;
	p[0].Y = 1;
	for(int i = 1; i <= N - 10; i ++) p[i].Y = p[i - 1].Y * BASE % MOD2;
	int T;
	cin >> T;
	while(T --) {
		int n;
		cin >> n;
		scanf("%s", s[0] + 1);
		scanf("%s", s[1] + 1);
		all = 0;
		int now = 0;
		top = 0;
		for(int i = 1; i <= n; i ++, now ^= 1) {
			pii tmp = pii(0, 0), nhash = pii(0, 0);
			if(now) {
				tmp.X = (s[0][i - 1] * BASE + s[1][i - 1]) % MOD;
				tmp.Y = (s[0][i - 1] * BASE + s[1][i - 1]) % MOD2;
				for(int j = i - 1; j >= 1; j --) nhash.X = (nhash.X * BASE + s[0][j]) % MOD;
				for(int j = 1; j <= i - 1; j ++) nhash.X = (nhash.X * BASE + s[1][j]) % MOD;
				for(int j = i - 1; j >= 1; j --) nhash.Y = (nhash.Y * BASE + s[0][j]) % MOD2;
				for(int j = 1; j <= i - 1; j ++) nhash.Y = (nhash.Y * BASE + s[1][j]) % MOD2;

			}
			else {
				tmp.X = (s[1][i - 1] * BASE + s[0][i - 1]) % MOD;
				tmp.Y = (s[1][i - 1] * BASE + s[0][i - 1]) % MOD2;
				for(int j = i - 1; j >= 1; j --) nhash.X = (nhash.X * BASE + s[1][j]) % MOD;
				for(int j = 1; j <= i - 1; j ++) nhash.X = (nhash.X * BASE + s[0][j]) % MOD;
				for(int j = i - 1; j >= 1; j --) nhash.Y = (nhash.Y * BASE + s[1][j]) % MOD2;
				for(int j = 1; j <= i - 1; j ++) nhash.Y = (nhash.Y * BASE + s[0][j]) % MOD2;
			}
			for(int j = 1; j <= top; j ++) {
				h[j].X = (p[(i - 2) * 2].X * tmp.X + h[j].X) % MOD;
				h[j].Y = (p[(i - 2) * 2].Y * tmp.Y + h[j].Y) % MOD2;
			}
			h[++ top] = nhash;
			pii cur = pii(0, 0);
			if(now) {
				for(int j = i; j <= n; j ++) cur.X = (cur.X * BASE + s[1][j]) % MOD;
				for(int j = n; j >= i; j --) cur.X = (cur.X * BASE + s[0][j]) % MOD;
				for(int j = i; j <= n; j ++) cur.Y = (cur.Y * BASE + s[1][j]) % MOD2;
				for(int j = n; j >= i; j --) cur.Y = (cur.Y * BASE + s[0][j]) % MOD2;
			}
			else {
				for(int j = i; j <= n; j ++) cur.X = (cur.X * BASE + s[0][j]) % MOD;
				for(int j = n; j >= i; j --) cur.X = (cur.X * BASE + s[1][j]) % MOD;
				for(int j = i; j <= n; j ++) cur.Y = (cur.Y * BASE + s[0][j]) % MOD2;
				for(int j = n; j >= i; j --) cur.Y = (cur.Y * BASE + s[1][j]) % MOD2;
			}
			for(int j = 1; j <= top; j ++) {
				pii nowhash = pii( (p[(i - 1) * 2].X * cur.X + h[j].X) % MOD, (p[(i - 1) * 2].Y * cur.Y + h[j].Y) % MOD2);
			   	mp[++ all] = (nowhash.X << 32) | nowhash.Y;
			}
		}

		now = 1;
		top = 0;
		for(int i = 1; i <= n; i ++, now ^= 1) {
			pii tmp = pii(0, 0), nhash = pii(0, 0);
			if(now) {
				tmp.X = (s[0][i - 1] * BASE + s[1][i - 1]) % MOD;
				tmp.Y = (s[0][i - 1] * BASE + s[1][i - 1]) % MOD2;
				for(int j = i - 1; j >= 1; j --) nhash.X = (nhash.X * BASE + s[0][j]) % MOD;
				for(int j = 1; j <= i - 1; j ++) nhash.X = (nhash.X * BASE + s[1][j]) % MOD;
				for(int j = i - 1; j >= 1; j --) nhash.Y = (nhash.Y * BASE + s[0][j]) % MOD2;
				for(int j = 1; j <= i - 1; j ++) nhash.Y = (nhash.Y * BASE + s[1][j]) % MOD2;

			}
			else {
				tmp.X = (s[1][i - 1] * BASE + s[0][i - 1]) % MOD;
				tmp.Y = (s[1][i - 1] * BASE + s[0][i - 1]) % MOD2;
				for(int j = i - 1; j >= 1; j --) nhash.X = (nhash.X * BASE + s[1][j]) % MOD;
				for(int j = 1; j <= i - 1; j ++) nhash.X = (nhash.X * BASE + s[0][j]) % MOD;
				for(int j = i - 1; j >= 1; j --) nhash.Y = (nhash.Y * BASE + s[1][j]) % MOD2;
				for(int j = 1; j <= i - 1; j ++) nhash.Y = (nhash.Y * BASE + s[0][j]) % MOD2;
			}
			for(int j = 1; j <= top; j ++) {
				h[j].X = (p[(i - 2) * 2].X * tmp.X + h[j].X) % MOD;
				h[j].Y = (p[(i - 2) * 2].Y * tmp.Y + h[j].Y) % MOD2;
			}
			h[++ top] = nhash;
			pii cur = pii(0, 0);
			if(now) {
				for(int j = i; j <= n; j ++) cur.X = (cur.X * BASE + s[1][j]) % MOD;
				for(int j = n; j >= i; j --) cur.X = (cur.X * BASE + s[0][j]) % MOD;
				for(int j = i; j <= n; j ++) cur.Y = (cur.Y * BASE + s[1][j]) % MOD2;
				for(int j = n; j >= i; j --) cur.Y = (cur.Y * BASE + s[0][j]) % MOD2;
			}
			else {
				for(int j = i; j <= n; j ++) cur.X = (cur.X * BASE + s[0][j]) % MOD;
				for(int j = n; j >= i; j --) cur.X = (cur.X * BASE + s[1][j]) % MOD;
				for(int j = i; j <= n; j ++) cur.Y = (cur.Y * BASE + s[0][j]) % MOD2;
				for(int j = n; j >= i; j --) cur.Y = (cur.Y * BASE + s[1][j]) % MOD2;
			}
			for(int j = 1; j <= top; j ++) {
				pii nowhash = pii( (p[(i - 1) * 2].X * cur.X + h[j].X) % MOD, (p[(i - 1) * 2].Y * cur.Y + h[j].Y) % MOD2);
			   	mp[++ all] = (nowhash.X << 32) | nowhash.Y;
			}
		}

		for(int i = 1; i <= n / 2; i ++) swap(s[0][i], s[0][n - i + 1]), swap(s[1][i], s[1][n - i + 1]);

		now = 0;
		top = 0;
		for(int i = 1; i <= n; i ++, now ^= 1) {
			pii tmp = pii(0, 0), nhash = pii(0, 0);
			if(now) {
				tmp.X = (s[0][i - 1] * BASE + s[1][i - 1]) % MOD;
				tmp.Y = (s[0][i - 1] * BASE + s[1][i - 1]) % MOD2;
				for(int j = i - 1; j >= 1; j --) nhash.X = (nhash.X * BASE + s[0][j]) % MOD;
				for(int j = 1; j <= i - 1; j ++) nhash.X = (nhash.X * BASE + s[1][j]) % MOD;
				for(int j = i - 1; j >= 1; j --) nhash.Y = (nhash.Y * BASE + s[0][j]) % MOD2;
				for(int j = 1; j <= i - 1; j ++) nhash.Y = (nhash.Y * BASE + s[1][j]) % MOD2;

			}
			else {
				tmp.X = (s[1][i - 1] * BASE + s[0][i - 1]) % MOD;
				tmp.Y = (s[1][i - 1] * BASE + s[0][i - 1]) % MOD2;
				for(int j = i - 1; j >= 1; j --) nhash.X = (nhash.X * BASE + s[1][j]) % MOD;
				for(int j = 1; j <= i - 1; j ++) nhash.X = (nhash.X * BASE + s[0][j]) % MOD;
				for(int j = i - 1; j >= 1; j --) nhash.Y = (nhash.Y * BASE + s[1][j]) % MOD2;
				for(int j = 1; j <= i - 1; j ++) nhash.Y = (nhash.Y * BASE + s[0][j]) % MOD2;
			}
			for(int j = 1; j <= top; j ++) {
				h[j].X = (p[(i - 2) * 2].X * tmp.X + h[j].X) % MOD;
				h[j].Y = (p[(i - 2) * 2].Y * tmp.Y + h[j].Y) % MOD2;
			}
			h[++ top] = nhash;
			pii cur = pii(0, 0);
			if(now) {
				for(int j = i; j <= n; j ++) cur.X = (cur.X * BASE + s[1][j]) % MOD;
				for(int j = n; j >= i; j --) cur.X = (cur.X * BASE + s[0][j]) % MOD;
				for(int j = i; j <= n; j ++) cur.Y = (cur.Y * BASE + s[1][j]) % MOD2;
				for(int j = n; j >= i; j --) cur.Y = (cur.Y * BASE + s[0][j]) % MOD2;
			}
			else {
				for(int j = i; j <= n; j ++) cur.X = (cur.X * BASE + s[0][j]) % MOD;
				for(int j = n; j >= i; j --) cur.X = (cur.X * BASE + s[1][j]) % MOD;
				for(int j = i; j <= n; j ++) cur.Y = (cur.Y * BASE + s[0][j]) % MOD2;
				for(int j = n; j >= i; j --) cur.Y = (cur.Y * BASE + s[1][j]) % MOD2;
			}
			for(int j = 1; j <= top; j ++) {
				pii nowhash = pii( (p[(i - 1) * 2].X * cur.X + h[j].X) % MOD, (p[(i - 1) * 2].Y * cur.Y + h[j].Y) % MOD2);
			   	mp[++ all] = (nowhash.X << 32) | nowhash.Y;
			}
		}
		now = 1;
		top = 0;
		for(int i = 1; i <= n; i ++, now ^= 1) {
			pii tmp = pii(0, 0), nhash = pii(0, 0);
			if(now) {
				tmp.X = (s[0][i - 1] * BASE + s[1][i - 1]) % MOD;
				tmp.Y = (s[0][i - 1] * BASE + s[1][i - 1]) % MOD2;
				for(int j = i - 1; j >= 1; j --) nhash.X = (nhash.X * BASE + s[0][j]) % MOD;
				for(int j = 1; j <= i - 1; j ++) nhash.X = (nhash.X * BASE + s[1][j]) % MOD;
				for(int j = i - 1; j >= 1; j --) nhash.Y = (nhash.Y * BASE + s[0][j]) % MOD2;
				for(int j = 1; j <= i - 1; j ++) nhash.Y = (nhash.Y * BASE + s[1][j]) % MOD2;

			}
			else {
				tmp.X = (s[1][i - 1] * BASE + s[0][i - 1]) % MOD;
				tmp.Y = (s[1][i - 1] * BASE + s[0][i - 1]) % MOD2;
				for(int j = i - 1; j >= 1; j --) nhash.X = (nhash.X * BASE + s[1][j]) % MOD;
				for(int j = 1; j <= i - 1; j ++) nhash.X = (nhash.X * BASE + s[0][j]) % MOD;
				for(int j = i - 1; j >= 1; j --) nhash.Y = (nhash.Y * BASE + s[1][j]) % MOD2;
				for(int j = 1; j <= i - 1; j ++) nhash.Y = (nhash.Y * BASE + s[0][j]) % MOD2;
			}
			for(int j = 1; j <= top; j ++) {
				h[j].X = (p[(i - 2) * 2].X * tmp.X + h[j].X) % MOD;
				h[j].Y = (p[(i - 2) * 2].Y * tmp.Y + h[j].Y) % MOD2;
			}
			h[++ top] = nhash;
			pii cur = pii(0, 0);
			if(now) {
				for(int j = i; j <= n; j ++) cur.X = (cur.X * BASE + s[1][j]) % MOD;
				for(int j = n; j >= i; j --) cur.X = (cur.X * BASE + s[0][j]) % MOD;
				for(int j = i; j <= n; j ++) cur.Y = (cur.Y * BASE + s[1][j]) % MOD2;
				for(int j = n; j >= i; j --) cur.Y = (cur.Y * BASE + s[0][j]) % MOD2;
			}
			else {
				for(int j = i; j <= n; j ++) cur.X = (cur.X * BASE + s[0][j]) % MOD;
				for(int j = n; j >= i; j --) cur.X = (cur.X * BASE + s[1][j]) % MOD;
				for(int j = i; j <= n; j ++) cur.Y = (cur.Y * BASE + s[0][j]) % MOD2;
				for(int j = n; j >= i; j --) cur.Y = (cur.Y * BASE + s[1][j]) % MOD2;
			}
			for(int j = 1; j <= top; j ++) {
				pii nowhash = pii( (p[(i - 1) * 2].X * cur.X + h[j].X) % MOD, (p[(i - 1) * 2].Y * cur.Y + h[j].Y) % MOD2);
			   	mp[++ all] = (nowhash.X << 32) | nowhash.Y;
			}
		}
		sort(mp + 1, mp + 1 + all);
		int ans = unique(mp + 1, mp + 1 + all) - (mp + 1);
		printf("%d\n", ans);

	}
}


kalilili
关注
专栏目录
『杭电1046』Gridland
漠宸离若的博客
05-25 291
Problem Description For years, computer scientists have been trying to find efficient solutions to different computing problems. For some of them efficient algorithms are already available, these are the “easy” problems like sorting, evaluating a polynom
POJ 1450 Gridland G++
woniupengpeng的专栏
12-05 253
#include #include using namespace std; //谢谢老师 int main() { int NUM; cin>>NUM; for(int i=0;i<NUM;i++) { int x,y; cin>>x>>y; cout<<"Scenario #"<<i+1<<":"<<endl; double jg; if((x*y)%2==0
hankerrank 刷题二( Python 基础）
theOne_Neo
01-10 560
1. 题一： Merge the Tools. 给出一个string, 和整数k。 把string等分成k个substring, (string长度是k的倍数)， 输出每个substring但substring里字母不重复。 example: 'HOWAREUUU' 输出： ‘HOW', 'ARE', 'U'。 思路，
Codeforeces 727 E 字符串双Hash 2017/1/12
I good vegetable a!
01-14 1231
题目链接：见这里 题意：n个长度为k的字符串，首尾相接，按顺时针顺序写在一张CD上，每个字符串只写一次总字符串长度小于1e6。保证每个字符串不同。这样CD上就有了一个环形字符串，长度是n*k。又给出g个长度为k的字符串列表（编号从1到g），按照顺时针打印CD上字符串的编号。保证每个字符串不同。保证这g个字符串长度的和小于2*1e6。 下面代码和思路参考了Wannafly每日一题，顺便学会了Has
字符串哈希详解，单hash，双hash，滚动哈希
最新发布
EQUINOX1的博客
07-12 1247
关于 M，由于 M 我们要取一个比较大的质数，而出题人往往对一些比较经典的质数如1e9 + 7、998244353等构造一堆卡哈希的数据，所以我们往往通过捕获一个随机数，根据随机数往下再取质数，来尽可能避免被hack。，多了也没必要，字符串哈希往往是作为算法优化的某一步骤，如果双hash都能被卡，说明题目可以采取其它优化策略，如：AC自动机、SA等。显然，有时会存在多个不同的字符串哈希值相同的情况，我们通常的处理策略是巧妙设置p和M的值，往往取p为某个质数，M为某个大质数。但是，字符串哈希始终是有风险的。
字符串hash双值hash
qq_45778406的博客
02-21 3107
双值Hash就是用两个不同的mod值来计算Hash，如果两个Hash值都相等才认为是同一个字符串，Hash冲突概率降低了很多，但是常数大，容易被卡。时间上：自然溢出法<单Hash+大质数<双Hash+大质数。 Hash的几个常用公式: Hash递推： Hash[0]=0; Hash[i]=(Hash[i-1]*p+s[i]-‘a’+1)%mod; 区间Hash值： Hash[L…R]=(Hash[R]-Hash[L]*p^(R-L+1)+mod)%mod;这里减法可能会溢出 eg: ha
HackerRank网站，为编码程序员们提供一个以编码谜题和现实生活中遇到的编码难题为基础的新兴的社交平台...
01-09 461
https://www.hackerrank.com/ HackerRank网站，为编码程序员们提供一个以编码谜题和现实生活中遇到的编码难题为基础的新兴的社交平台。 HackerRank网站是一个为编码程序员们提供的新型社交平台。HackerRank 公司受风险投资公司Y Combinator 的资金支持，该公司的创始人与招聘...
小明的魔法城堡（字符串双哈希）
AC__dream的博客
09-15 314
题目链接：信息学奥赛比赛系统 | 小明的魔法城堡 (qduoj.com) 这道题目是判断每个字符串去掉一个字符后有没有与其相同的字符串出现，显然是要用哈希来处理，需要注意的是一般题目最好用双哈希，这样可以尽可能地降低冲突率，下面来说一下这道题目用哈希该如何处理。 如果两个字符串完全相同，那么他们的哈希值无论在什么进制下都会相同，我们可以先把所有字符串的哈希值都存到map里面，然后我们再检查每一个字符串删掉一个字符后的字符串的哈希值是否在map里面出现过就好了，求每个字符串总的哈希值我在这就不多说了，如果
gridland:格陵兰
05-06
"Gridland: 格陵兰" 是一个由Doublespeak Games开发的独特游戏，它融合了建造元素和可能的策略玩法，带给玩家一种奇特的时间消磨体验。从描述中可以看出，这个游戏可能涉及到编程和构建环境，因为提到了使用 `ant` ...
HDU 1046 & POJ 1450 Gridland【有趣的数学题】
AC_Dreameng
07-22 1774
规律：当n，m不全为奇数的时候，最短路径就是n*m； 当n，m全为奇数的时候，必然要走一条斜线，就多走了0.41（即根号2），最短路径即为：n*m+0.41.
北大Acm分类
07-20
**题目描述**：字符串距离与转换过程，可能涉及到编辑距离等问题。 **解题思路**：编辑距离是一个经典的动态规划问题。 --- ##### 1462 Team Them Up! **题目描述**：组队问题，可能是寻找最优组合。 **解题...
hackerrank题目解答
02-08
hackerrank上面的经典题目解答，自习看完可以复习算法。
cf edu152 C. Binary String Copying（字符串双哈希）
qq_23096319的博客
07-28 482
这个方法可以拓展到由任意字符构成的字符串，不过编码比较复杂，要取模。同时单哈希还会被卡，要用两个基做双哈希才行。的字符排序，实际就是调整为0在前1在后，问得到的m个副本有多少个不同串。，可以通过拼接10,000,11,0四个串的哈希值得到。给定一个01字符串，长度为n，拷贝m份，对每一份进行相应操作：将。去求某个字符串的哈希值了。逆过来，也可以求某个子串的哈希值，将基的幂次预处理可以。可以标识一个拷贝串，直接将数对放进集合中统计就可以了。预处理连续0串和1串的哈希值。，和往右第一个1的位置。
compress words (KMP/字符串哈希，双哈希）
qq_51070956的博客
02-15 1237
compress words连接若干单词，规避单词尾和下一个单词首的重复字段kmp求最长相同前后缀字符串双哈希 题目链接 连接若干单词，规避单词尾和下一个单词首的重复字段 kmp求最长相同前后缀 交到coedforce上，next数组报错，应该是同名了，保险起见改成nex 还是对kmp算法的理解不够深刻，成功匹配时j=le, 不成功，一种是不相等，终究还是主串比完了也没能全部匹配上 就看最后这个j表示匹配哪儿 如果主串最后一个字符也未能与s[0]比较成功，j就会变为-1，继而加一得0 想象匹
POJ3461 字符串双HASH
Free loop！ 爱上编程！
02-04 588
转自http://blog.csdn.net/huangkuizuiniu/article/details/50619698 #include #include #include #define ull unsigned long long using namespace std; const ull B=1e8+5,C=1e8+7; const int maxn=100001; ch
哈希和双哈希
Freopen的博客
11-03 725
哈希自然溢出 #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; #include&lt;set&gt; #define LL long long #define maxn 10005 #define S 131 using namespace std; int n; char s[maxn]; set...
Double Hashing（双重hash）
热门推荐
永生只是一场幻梦
12-09 2万+
双重哈希是开放寻址哈希表中的冲突解决技术。双重哈希的思想是在发生冲突时对键做第二个哈希函数。 双重哈希可以处理:(hash1(key) + i * hash2(key)) % TABLE_SIZE 这里 hash1() 、 hash2() 是hash 函数，TABLE_SIZE 是hash表大小 (如果发生冲突，i递增然后重复运算) 通俗的二次Hash函数：hash2(key) ...
双哈希
weixin_43911947的博客
05-16 1529
就是构造两个哈希函数，然后将结果记为pair存map，能够进一步减少冲突率 例题：Birthday Cake 题意 给你n个串，问有几对串可以拼成形如AA串。 思路 先对所有串跑一个哈希，然后遍历所有串，如果该串是ABA型那么就去找B的个数，自然溢出法还差一点，双哈希就过了。 ac代码 #include<bits/stdc++.h> using namespace std; #define endl '\n' #define ll long long #define ull un
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值