hihocoder1579

最新推荐文章于 2019-07-27 13:47:08 发布
最新推荐文章于 2019-07-27 13:47:08 发布
阅读量182 收藏
点赞数
分类专栏： 高精度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guoshiyuan484/article/details/78608141
版权

此题应该算是开荒题了吧。。。

主要注意对于一个后缀的排名显然第一位是最重要的，然后对于两个不同的后缀第一位什么时候能相同呢？就是如果a<b那么在a后的后缀h，和在b后的后缀k依然是h<k的话那么就a=b就是可能的如果h>k那么必然有a<b

这样更具题目给的条件我们就把此题转化成了一个组合数学问题，

对于样例

第一个级别对应位置4，位置5的级别是4

第二级别对应位置3，位置4的级别是1

因为4>1,所以第一级别的字母一定是比第二级别的字母小的

然后这样一个一个推下去。看哪些相邻级别的字母能相同

然后问题就是一个插板问题了

首先一定会有总共25个版，每个版对应一个字母级别从左到右是a b c d .....，然后前面我们算出了一定会在某些地方插bannum个版，这些版是位置不变而且数目也不变的，就只能插在出现断层的字母之间,还剩下25-bannum个版，我们让这25-bannum个版插进n个字母中这应该是个很简单的组合问题了。插了这些版再插固定版所以答案就是

C(25-bannum                                                                                                                                                                                                                                                                     n+25-bannum)

然后要写高精度。。。

开荒+高精度第一次写。。。所以我已经wa到麻木了。。。。。。然后终于过了。。。注意c(0,n)这个要特判对于很可能错

写得很多，大多数都是没用的，不过我只是拿来研究高精度了。。。其实还有很多地方需要完善，以后来弥补。。。

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
typedef long long ll;
const ll base = 1000000000;
const ll poww[10] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
struct Big_int
{
	ll num[8000];
	int cnt;
	friend istream& operator>>(istream &in, Big_int &c)
	{
		char s[3000];
		for (int i = 0; i < 3000; i++)
			c.num[i] = 0;
		scanf("%s", s+1);
		int len = strlen(s+1);
		c.cnt = (len-1)/ 9 + 1;
		for (int i = 1; i <= len; i++)
		{
			c.num[(len - i) / 9 + 1] += (s[i] - '0')*poww[(len - i) % 9];
		}
		return in;
	}
	Big_int& operator=(ll a)
	{
		for (int i = 0; i <3000; i++)
			num[i] = 0;
		int tot = 1;
		while (a)
		{
			num[tot] = a%base;
			a /= base;
			tot++;
		}
		cnt = tot - 1;
		return *this;
	}
	Big_int& operator*=(ll a)
	{
		Big_int c;
		c = 0;
		for (int i = 1; i <= cnt; i++)
		{
			c.num[i]+= num[i] * a;
			if (c.num[i]>base)
				c.num[i + 1] += c.num[i] / base,
				c.num[i] %= base;
		}
		if (c.num[cnt + 1])
			cnt++;
		while (c.num[cnt] > base)
		{
			c.num[cnt + 1] += c.num[cnt] / base,
				c.num[cnt] %= base;
			cnt++;
		}
		for (int i = 1; i <= cnt; i++)
			num[i] = c.num[i];
		return *this;
	}
	Big_int& operator/=(ll a)
	{
		for (int i = cnt; i >= 1; i--)
		{
			if (i - 1)
			{
				num[i - 1] += (num[i] % a)*base;
			}
			num[i] /= a;
		}
		while (num[cnt] == 0)
			cnt--;
		return *this;
	}
	friend bool operator>(Big_int &a, Big_int &b)
	{
		if (a.cnt == b.cnt)
		{
			for (int i = a.cnt; i >= 1; i--)
			{
				if (a.num[i] > b.num[i])
					return true;
			}
			return false;
		}
		else
		{
			return a.cnt > b.cnt;
		}
	}
	friend ostream& operator<<(ostream &out, Big_int &c)
	{
		if (c.num[0] == 1)
			printf("-");
		printf("%lld", c.num[c.cnt]);
		for (int i = c.cnt - 1; i >= 1; i--)
		{
			printf("%09lld", c.num[i]);
		}
		return out;
	}
};
Big_int operator*(Big_int &a, Big_int &b)
{
	Big_int c;
	c = 0;
	if (b > a)
		swap(a, b);
	int get1 = 0, get2 = 0;
	for (int i = 1; i <= b.cnt; i++)
	{
		int get1 = 0, get2 = 0;
		for (int j = 1; j <= a.cnt+1; j++)
		{
			get2 = (a.num[j] * b.num[i]) / base;
			c.num[i + j - 1] += ((a.num[j] * b.num[i]) % base)+get1;
			if (c.num[i + j - 1] >=base)
			{
				get2 += c.num[i + j - 1] / base;
				c.num[i + j - 1] %= base;
			}
			get1 = get2;
		}
	}
	if (c.num[a.cnt + b.cnt])
		c.cnt = a.cnt + b.cnt;
	else
		c.cnt = a.cnt + b.cnt-1;
	while (c.num[c.cnt] > base)
	{
		c.num[c.cnt + 1] += c.num[c.cnt] / base;
		c.num[c.cnt] %= base;
		c.cnt++;
	}
	return c;
}
Big_int& operator-(Big_int &a, Big_int &b)
{
	if (b > a)
	{
		swap(a, b);
		a.num[0] = 1;
	}
	for (int i = 1; i <= b.cnt; i++)
	{
		if (a.num[i] < b.num[i])
		{
			a.num[i + 1]--;
			a.num[i] += base;
		}
		a.num[i] -= b.num[i];
	}
	return a;
}
Big_int& operator+(Big_int &a, Big_int &b)
{
	if (b > a)
		swap(a, b);
	for (int i = 1; i <= b.cnt; i++)
	{
		a.num[i] += b.num[i];
		if (a.num[i] >= base)
		{
			a.num[i + 1] += (a.num[i] / base);
			a.num[i] %= base;
		}
	}
	if (a.num[a.cnt + 1])
		a.cnt++;
	return a;
}
int n, t;
void solve(int bannum)
{
	ll all = n + 25- bannum;
	ll num = 25 - bannum;
	//ll num2 = all - num;
	//if (num > num2)
	//	swap(num, num2);
	Big_int a ;
	a = all;
	all--;
	for (int i = 2; i <= num; i++)
	{
		a *= all;
		all--;
	}
	//cout << a << endl;
	if (bannum == 25)
	{
		printf("1\n");
	}
	else
	{
		for (int i = 1; i <= num; i++)
			a /= i;
		cout << a << endl;
	}
}
int a[100020], pos[100020];
int main()
{
	/*ll b = 31 * 30 * 29 * 28 * 27 * 26;
	b /= 720;
	cout << b << endl;
	Big_int aa;
	aa = 1;
	for (int i = 31; i >= 26; i--)
		aa *= i;
	aa /= 720;
	cout << aa << endl;*/
	int t;
	scanf("%d", &t);;
	while (t--)
	{
		scanf("%d", &n);
		for (int i = 1; i <= n; i++)
			scanf("%d", &a[i]);
		for (int i = 1; i <= n; i++)
			pos[a[i]] = i;
		int bannum = 0;
		for (int i = 2; i <= n; i++)
			if (pos[a[i - 1] + 1] > pos[a[i] + 1])
				bannum++;
		//cout << bannum << endl;
		if (bannum > 25)
			printf("0\n");
		else
			solve(bannum);
	}
	return 0;
}

指针版高精度。其实高精还是适合用指针写，不过不好调试。。。

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const ll base = 100;
const ll bl = 2;
ll poww[10] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
struct Big_int
{
	ll *num;
	int cnt;
	Big_int()
	{
		
	}
	~Big_int()
	{
		delete []num;
	}
	Big_int(ll get,int kind)
	{
		if (kind == 1)
			num = new ll[80000];
		if (kind == 2)
			num = new ll[8];
		int i;
		for ( i = 1; get; i++)
		{
			num[i] = get%base;
			get /= base;
		}
		cnt = i-1;
	}
	friend istream& operator>>(istream &in, Big_int *c)
	{
		static char s[72000];
		scanf("%s", s+1);
		int len = strlen(s+1);
		c->num = new ll[9*len];
		c->cnt = len / bl + 1;
		for (int i = 0; i <= c->cnt; i++)
			c->num[i] = 0;
		for (int i = 1; i <= len; i++)
		{
			c->num[(len - i) / bl + 1] += (s[i] - '0')*poww[(len - i) % bl];
		}
		if (c->num[c->cnt] == 0)
			c->cnt--;
		return in;
	}
	Big_int& operator*=(ll a)
	{
		ll get1 = 0, get2 = 0;
		for (int i = 1; i <= cnt+1; i++)
		{
			if (i == cnt + 1)
				num[i] = 0;
			get1 = (num[i] * a) / base;
			num[i] = (num[i] * a) % base+get2;
			get2 = get1;
			if (num[i] >= base&&i!=cnt+1)
			{
				get2 += num[i] / base;
				num[i] %= base;
			}
			
		}
		if (num[cnt + 1])
			cnt++;
		while (num[cnt] > base)
		{
			num[cnt + 1] = 0;
			num[cnt + 1] += num[cnt] / base;
			num[cnt] %= base;
			cnt++;
		}
		return *this;
	}
	friend ostream& operator<<(ostream &out, Big_int *c)
	{
		printf("%lld", c->num[c->cnt]);
		for (int i = c->cnt - 1; i >= 1; i--)
		{
			printf("%02lld", c->num[i]);
		}
		return out;
	}
};
Big_int *qq,*pp,*lgl;
Big_int kk;
int main()
{
	qq = new Big_int(20,1);
	pp = new Big_int(20,1);
	lgl = new Big_int(20, 1);
	return 0;
}*/



再存一个自己写的高精度

//高精度
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
typedef long long ll;
const ll base = 1000000000;
const ll poww[10] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
struct Big_int
{
	ll num[8000];
	int cnt;
	friend istream& operator>>(istream &in, Big_int &c)
	{
		char s[3000];
		for (int i = 0; i < 3000; i++)
			c.num[i] = 0;
		scanf("%s", s+1);
		int len = strlen(s+1);
		c.cnt = (len-1)/ 9 + 1;
		for (int i = 1; i <= len; i++)
		{
			c.num[(len - i) / 9 + 1] += (s[i] - '0')*poww[(len - i) % 9];
		}
		return in;
	}
	Big_int& operator=(ll a)
	{
		for (int i = 0; i <3000; i++)
			num[i] = 0;
		int tot = 1;
		while (a)
		{
			num[tot] = a%base;
			a /= base;
			tot++;
		}
		cnt = tot - 1;
		return *this;
	}
	Big_int& operator*=(ll a)
	{
		Big_int c;
		c = 0;
		for (int i = 1; i <= cnt; i++)
		{
			c.num[i]+= num[i] * a;
			if (c.num[i]>base)
				c.num[i + 1] += c.num[i] / base,
				c.num[i] %= base;
		}
		if (c.num[cnt + 1])
			cnt++;
		while (c.num[cnt] > base)
		{
			c.num[cnt + 1] += c.num[cnt] / base,
				c.num[cnt] %= base;
			cnt++;
		}
		for (int i = 1; i <= cnt; i++)
			num[i] = c.num[i];
		return *this;
	}
	Big_int& operator/=(ll a)
	{
		for (int i = cnt; i >= 1; i--)
		{
			if (i - 1)
			{
				num[i - 1] += (num[i] % a)*base;
			}
			num[i] /= a;
		}
		while (num[cnt] == 0)
			cnt--;
		return *this;
	}
	friend bool operator>(Big_int &a, Big_int &b)
	{
		if (a.cnt == b.cnt)
		{
			for (int i = a.cnt; i >= 1; i--)
			{
				if (a.num[i] > b.num[i])
					return true;
			}
			return false;
		}
		else
		{
			return a.cnt > b.cnt;
		}
	}
	friend ostream& operator<<(ostream &out, Big_int &c)
	{
		if (c.num[0] == 1)
			printf("-");
		printf("%lld", c.num[c.cnt]);
		for (int i = c.cnt - 1; i >= 1; i--)
		{
			printf("%09lld", c.num[i]);
		}
		return out;
	}
};
Big_int operator*(Big_int &a, Big_int &b)
{
	Big_int c;
	c = 0;
	if (b > a)
		swap(a, b);
	int get1 = 0, get2 = 0;
	for (int i = 1; i <= b.cnt; i++)
	{
		int get1 = 0, get2 = 0;
		for (int j = 1; j <= a.cnt+1; j++)
		{
			get2 = (a.num[j] * b.num[i]) / base;
			c.num[i + j - 1] += ((a.num[j] * b.num[i]) % base)+get1;
			if (c.num[i + j - 1] >=base)
			{
				get2 += c.num[i + j - 1] / base;
				c.num[i + j - 1] %= base;
			}
			get1 = get2;
		}
	}
	if (c.num[a.cnt + b.cnt])
		c.cnt = a.cnt + b.cnt;
	else
		c.cnt = a.cnt + b.cnt-1;
	while (c.num[c.cnt] > base)
	{
		c.num[c.cnt + 1] += c.num[c.cnt] / base;
		c.num[c.cnt] %= base;
		c.cnt++;
	}
	return c;
}
Big_int& operator-(Big_int &a, Big_int &b)
{
	if (b > a)
	{
		swap(a, b);
		a.num[0] = 1;
	}
	for (int i = 1; i <= b.cnt; i++)
	{
		if (a.num[i] < b.num[i])
		{
			a.num[i + 1]--;
			a.num[i] += base;
		}
		a.num[i] -= b.num[i];
	}
	return a;
}
Big_int& operator+(Big_int &a, Big_int &b)
{
	if (b > a)
		swap(a, b);
	for (int i = 1; i <= b.cnt; i++)
	{
		a.num[i] += b.num[i];
		if (a.num[i] >= base)
		{
			a.num[i + 1] += (a.num[i] / base);
			a.num[i] %= base;
		}
	}
	if (a.num[a.cnt + 1])
		a.cnt++;
	return a;
}
int n, t;
void solve(int bannum)
{
	ll all = n + 25- bannum;
	ll num = 25 - bannum;
	//ll num2 = all - num;
	//if (num > num2)
	//	swap(num, num2);
	Big_int a ;
	a = all;
	all--;
	for (int i = 2; i <= num; i++)
	{
		a *= all;
		all--;
	}
	//cout << a << endl;
	if (bannum == 25)
	{
		printf("1\n");
	}
	else
	{
		for (int i = 1; i <= num; i++)
			a /= i;
		cout << a << endl;
	}
}
int a[100020], pos[100020];
int main()
{
	/*ll b = 31 * 30 * 29 * 28 * 27 * 26;
	b /= 720;
	cout << b << endl;
	Big_int aa;
	aa = 1;
	for (int i = 31; i >= 26; i--)
		aa *= i;
	aa /= 720;
	cout << aa << endl;*/
	int t;
	scanf("%d", &t);;
	while (t--)
	{
		scanf("%d", &n);
		for (int i = 1; i <= n; i++)
			scanf("%d", &a[i]);
		for (int i = 1; i <= n; i++)
			pos[a[i]] = i;
		int bannum = 0;
		for (int i = 2; i <= n; i++)
			if (pos[a[i - 1] + 1] > pos[a[i] + 1])
				bannum++;
		//cout << bannum << endl;
		if (bannum > 25)
			printf("0\n");
		else
			solve(bannum);
	}
	return 0;
}



guoshiyuan484
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hihocoder week1 answer
11-17
微软hiho coder平台第一周题目，最长回文子串。
hihocoder:hihocoder上的系列题解(http
05-18
#hihocoder hihocoder上的系列题解()
HihoCoder 1579 组合数学
zhenlingcn的博客
09-28 454
题意问符合一个后缀数组的小写字符串组合有多少种题解首先观察后缀数组，4 3 2 5 1。可以得到一些信息: 1、4<3<2<5<1一定是符合的 2、至于等号关系需要判断该位置后面的字符串与下一个位置后面字符串的关系，如果该位置后面字符串>下一个位置后面字符串，那么等号一定无法取到 3、关于后面字符串大小的判断，我们可以再次利用后缀数组进行判断，我们可以搞一个数组，记录以X开始的后缀在数组中的位
hihocoder 1579(排列组合)
weixin_30376509的博客
09-26 80
题意 　　给出一个长度为n的字符串的sa数组，n<=1e5，问有多少种不同的字符串的sa数组正好是输入的sa数组（字符串每个位置都是小写字母） 分析 　　sa数组描述的是字符的大小关系，而不是确切的字符，所以我们考虑位置的逻辑关系 　　首先一定有$s[sa[i-1]]<=s[sa[i]]$ 　　但是对于那些$rank[sa[i-1]+1]>rank[sa[i]+1]$的...
hihocoder1121
A Little Blog
08-06 225
import java.util.*;enum Color{ no, white, black }class Node{ private Color color; private int id; List<Integer> dateIds = new ArrayList<>(); Node(int id){ this.id = i
hihocoder 1722
qq_43251559的博客
07-27 148
#include <iostream> #include <string.h> #include <algorithm> using namespace std; struct node{     int x;     int pos; }; bool cmp(node a,node b){ &nbsp...
HihoCoder 1527 题解
Bule-Zst的博客
08-12 319
略略略
hihocoder #1096
yeqm_的博客
10-31 324
递归暴搜，注意的是乘积用int要爆 #include #include #include #include #include #include #include #include using namespace std; #define lch(i) ((i)<<1) #define rch(i) ((i)<<1|1) #define sqr(i) ((i)*(i
hihocoder-1050
x5gx5gx5g的博客
01-02 227
https://hihocoder.com/problemset/problem/1050 //树的直径 //8 树的结点数 这里树边数=结点数-1 //1 2 //1 3 //1 4 //4 5 //3 6 //6 7 //7 8 //法一（不带权重的模板）一次DFS+快速输入 //效率上来说法一比法二好，不论带不带快速输入 #include&amp;lt;cstdio&amp;gt; #include&amp;lt;...
hihocoder题库1014
基皮producer的工具仓库
10-10 850
今天做了下Trie树，虽然不难，但是还是费了一些功夫。 先上代码： #include #include #include //节点结构 typedef struct tNode{ char c; struct tNode *next[26]; long num; }tNode; //树结构 typedef struct tTree{ tNode *head; }tTree;
hihocoder #1057
yeqm_的博客
11-13 292
程序要满足 1、不能交叉，即一个程序要么完全包含在另一程序时间里面，要么互不相交 2、时间严格递增 #include #include #include #include #include #include #include #include #include #include using namespace std; #define lch(i) ((i)<<
hihocoder和leetcode-leetcode:leetcode
07-06
hihocoder和leetcode leetcode 目录名 功能 Array 数组 Backtracking 回溯 Bit_Manipulation 位操作 Design 数据结构设计 Divide_and_Conquer 分而治之 DP 动态规划 Hash_Table 哈希表 List 链表 Math 数学 Stack 栈...
hihocoder和leetcode-JInterview:J访谈
07-06
hihocoder和leetcode JInterview 一套完整的Java学习路径帮助自己拿到大厂Offier 目录 在线练习 在线面试编程 操作系统和团队工具 基础深入 框架源码 微服务架构 高并发分布式
hihocoder和leetcode-OJPractice:OJ实践
07-06
hihocoder和leetcode OJPractice ##文件夹组织方式（暂定）： 一级文件夹按照题库组织，即分别建立Hihocoder、Leetcode、POJ等文件夹 二级文件夹命名格式为： 题号_人名ID[_语言] ，如果语言不是C/C++请添加“_语言...
node-v5.11.0-x86.msi
05-07
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
41532698775097Facebook Lite_405.0.0.8.113_apkcombo.com.armeabi-v7a.apk
05-07
41532698775097Facebook Lite_405.0.0.8.113_apkcombo.com.armeabi-v7a.apk
2024-2030中国RDF制粒机市场现状研究分析与发展前景预测报告.docx
05-07
2024-2030中国RDF制粒机市场现状研究分析与发展前景预测报告
财务困境-RLPM模型.xlsx
最新发布
05-07
详细介绍及样例数据：https://blog.csdn.net/li514006030/article/details/138549562
基于python实现的Socket服务器与传感器通讯手段实现的家庭能源管理系统
05-07
【作品名称】：基于Socket作为服务器与传感器通讯手段实现的家庭能源管理系统 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
node-v9.10.0-linux-armv7l.tar.xz
05-07
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值