数据结构 on Zs's Blog

高精度计算pi

Mon, 20 Apr 2020 01:25:00 +0000

高精度计算PI值

题目描述

使用双向链表作为存储结构，请根据用户输入的一个整数（该整数表示精确到小数点后的位数，可能要求精确到小数点后 500 位），高精度计算PI值。提示：可以利用反三角函数幂级展开式来进行计算。

解题思路

求PI的算法

首先这道题是要求必须使用双向链表作为存储结构的，这个需要注意，而且也不能用数组计算完了之后挨个赋值给链表的每个节点，~~这是耍赖~~ 。

那么我们开始再想，用什么公式来求 PI 呢？这是一个问题。先没管题目的提示，我去百度了一通，发现了一个很神奇的算法，用三行就可以计算到圆周率小数点后800+位。

#include<cstdio>

using namespace std;

long a=1000,b,c=2800,d,e,f[2801],g;
int main(){
    for(;b-c;) f[b++]=a/5;
    for(;d=0,g=c*2;c-=14,printf("%.3d",e+d/a),e=d%a)
    for(b=c;d+=f[b]*a,f[b]=d%--g,d/=g--,--b;d*=b);
}

实验了一下发现居然真的是，而且效率还挺高的？看了一会实现的原理一直没看懂，作罢。

最后发现是找不到什么除了幂级展开还有啥高效率的算法了好像，还是考虑题目提示的 三角函数幂级展开。然后继续在网上搜索了一下，在学长的一个博客里发现了公式。 $$ f_{i} = \begin{cases} 1 & {i=1}\\ f_{i-1}\times \frac{i-1}{2\times i-1} & {i>1} \end{cases} $$

那么拿到了这个式子，我们就可以分析一下，怎么和链表结合起来做了。

链表的设计

双向链表，也就是每个节点有一个数据域，有前和后两个指针。我考虑到我们做加法和乘法是需要从后往前做，除法是需要从前往后做。因此需要双向遍历，我又添加了一个尾指针，记录当前链表的尾节点的地址，方便从后往前遍历，头节点可以保证从前往后遍历。设计如下：

typedef struct node
{
    int data;
    struct node *nxt; 
    struct node *pre;
    struct node *tail;
    node()   //构造函数，用于初始化
    {
        nxt = NULL;
        pre = NULL;
           tail = this;
        data = 0;
    }
}

数据域就用来存储每一位数字，好比 3.1415926 就从第一个节点到第八个节点依次存 31415926 。

乘法的实现

另出一个函数，函数声明类似于 void Multi(List L,int k)

乘法我们模拟竖式的乘法运算，考虑到这是一个 高精度大数 * 低精度整数 ，因此我们只需要从尾部到头部依次对每一位做乘法即可，考虑到进位问题，可以有两种办法

可以是先做完乘法，然后再回到尾部，再从尾到头依次处理进位，这样的好处是这两种操作分隔开了，操作起来难度不大，也比较好想。
可以是边做乘法边进位，我们定义一个 temp 用来存储低位到高一位的进位，这里要注意的是，对于某一位的操作不是先加上进位再做乘法，是先做乘法，再加低位的进位。

但是有一个问题我们需要注意，就是好比 52 * 3 ，这时候原来的两位数变成三位数了，因此需要我们在头节点和第一个节点之间增加新的节点，并且可能增加的不只是一个，只要 temp 这个进位大于等于10就需要一直创建新的节点来保证进位。

除法的实现

另出一个函数，函数声明类似于 void Division(List L,int k)

除法也是模拟竖式运算，这个是从头到尾进行处理，这一位的数据做完除法，余数作为下一位的**“进位”** ，这里可以边做边 “进位” 。这里这个进位不是乘法的那种进位，注意区分。

需要注意的是最后可能有除不尽的情况，这样我们就可以一直在尾部插入节点，然后处理一直处理数据到最大位数 或者 到 “进位” 为0为止 。最后不要忘记重置一下尾指针，指向新的尾节点。

加法的实现

函数声明类似于 void Sum(List L,List p) 。

加法的实现也是需要从后往前遍历，然后依次对每一位做加法。先取两个链表的尾节点出来，然后依次向前遍历相加，我们可以把相加的答案放在前面那个链表里面，注意这样是不需要返回值的，因为链表内部是通过地址索引的，我们改变的就是传入链表的值。

最后的整合

最后我们总共需要一个和链表，一个 $f_{i}$。和链表用于计算所有式子的累加和，而 $f_{i-1}$ 其实就是 $f_i$ 的上个阶段。我们每次把 $f_i$ 和和链表进行累加即可。

最后再对和链表乘2 即可。

代码实现

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>

using namespace std;

const int maxsize = 600;  // 设定求小数点后多少位
typedef struct node  // 双向链表的结构体
{

    int data;
    struct node *nxt;
    struct node *pre;
    struct node *tail;
    node()              //构造函数，用于初始化
    {
        data = 0;
        tail  = this;
        nxt = NULL;
        pre = NULL;
    }

}Node,*List;

void Mult(List Head,int k);      // 对链表每一位 *k
void Divi(List Head,int k);      // 对链表每一位 ÷k
void Sum(List a,List b);         // 对两个链表的数求和，所得数放在前面链表中
void InitList(List &L);          // 初始化链表，并把第一个节点值设为 1
void InitSum(List &L);           // 初始化最后存和的链表，并把第一个节点置为1
void Output(List L,int k);       // 输出一个链表，保留 k 位小数


int main()
{
    int n = 0;
    scanf("%d",&n);             
    List Head,S;
    InitList(Head); 
    InitSum(S);
    for(int i=2;i<=3000;i++)     //计算pi值
    {
        Mult(Head,i-1);
        Divi(Head,2*i-1);
        Sum(S,Head);
    }

    Mult(S,2);
    Output(S,n);
    return 0;
}

void Mult(List Head,int k)    // 对以Head为头节点的链表中的每一位做乘法
{
    List p = Head->tail;      // 先把指针指向链表的末尾，方便从后往前做乘法
    while(p != Head)          // 从前往后开始算乘法
    {
        p->data *= k;
        p = p->pre;
//      printf("I have done Multi.\n");
    }
    p = Head->tail;
    while(p != Head->nxt)     //开始处理进位 
    {
        p->pre->data += p->data /10;
        p->data %= 10;
        p = p->pre;
    }
    while( p->data > 10)      //一直处理最高位的进位 
    {
        List s = (List)malloc(sizeof(Node));
        s->data = p->data/10;
        p->data %= 10;
        s->pre = Head;
        s->nxt = p;
        p->pre = s;
        Head->nxt = s;
        p = s;
    }
}

void Divi(List Head,int k) // 对链表每一位除k
{
    int temp = 0,depth = 0;     //temp用于进位计算 ，depth 用于计算链表长度
    List p = Head->nxt;
    List t;                     // 存尾部节点
    while(p != NULL)            //模拟做除法
    {
        depth++; 
        p->data += temp*10; 
        temp = p->data % k;
        p->data /= k;
        t = p;
        p = p->nxt;
    }
    p = t;
    while(temp!=0 && depth <= maxsize)  // 如果除不尽，就一直往后拓展节点，但注意不要超过最大位数
    {
//      printf("I have done Division!\n");
        depth++;
        List s = (List)malloc(sizeof(Node));
        s->data = temp*10;
        s->nxt = NULL;
        s->pre = p;
        temp = s->data % k;
        s->data /= k;
        p->nxt = s;
        p = s;
    }
    Head->tail = p;
}

void Sum(List a,List b)  // 对两个链表的数求和，所得数放在前面链表中
{
    List p = a->tail,k = b->tail;  // 先指向各自的尾部，开始从前往后加
    while(p!=a && k!=b)  // 遍历到有一个到头节点为止
    {
        p->data += k->data;
        p->pre->data += p->data / 10;
        p->data %= 10;
        p = p->pre;
        k = k->pre;
    }
}

void InitList(List &L) // 初始化链表，并把第一个节点值设为 1
{
   L = (List)malloc(sizeof(Node));
   L->data = 0;
   List s = (List)malloc(sizeof(Node));
   s->data = 1;
   s->pre = L;
   L->nxt = s;
   L->pre = NULL;
   L->tail = s;
   s->nxt = NULL; 
}

void InitSum(List &L) // 初始化最后存和的链表，并把第一个节点置为1
{
    L = (List)malloc(sizeof(Node));
    L->nxt = NULL;
    L->pre = NULL;
    L->data = 0;
    List p = L;
    int depth = 0;
    while(depth <= maxsize)
    {
        List s = (List)malloc(sizeof(Node));
        s->data = 0;
        s->pre = p;
        p->nxt = s;
        s->nxt = NULL;
        p = s;
        depth++;
    }
    L->nxt->data = 1;
    L->tail = p;
}

void Output(List L,int k) //输出一个列表，保留 k 位小数
{
    List p = L->nxt;
    printf("%d.",p->data);
    p = p->nxt;
    int t = 0;
    while(p != NULL && t<k) 
    {
        t++;
        printf("%d",p->data);
        p = p->nxt;
    }
    printf("\n");
}

参考链接

单调队列和单调栈总结

Tue, 11 Feb 2020 00:40:00 +0000

前言

最近感觉遇到了好多单调队列和单调栈的问题，但是因为以前没学好，所以遇见了就一脸懵逼，然后绝对下决心来学一下。。感觉遇到啥都不会，这可咋办呐。。补不完的漏洞。

单调队列(Monotone queue)

单调队列，即单调递减或单调递增的队列。使用频率不高，但在有些程序中会有非同寻常的作用。

理解

顾名思义，他就是一个单调的队列，那么我们可以规定他是单调递增的还是单调递减的，他和普通的队列有点区别，队列一般是尾进头出，而单调队列要实现的话要确保头和尾都可以出，尾可以进。如果要用STL库的话可以用里面的双端队列。跟普通队列相比他的进队需要确保一个条件就是要不破坏原有序列的单调性，好比我们有一个单调递增的单调队列，也就是从队首到队尾是单调递增的，那么有一段序列是 $[2,3,1,5,8,7,4,2]$ ，我们从左到右依次入队。

队列中元素	关于元素进出的备注
2	2入队
2，3	3比2大，可以满足递增性质，入队
1	因为1比2，3都小，要满足递增性质，先把2，3出队，再将1入队
1，5	5比1大，可以满足递增性质，入队
1，5，8	8比5大，可以满足递增性质，入队
1，5，7	7小于8，大于5，要满足递增性质，我们把8出队，然后将7入队
1，4	4小于5、7，但是大于1，因此7，5依次出队，4入队
1，2	2小于4，大于1，因此4出队，2入队

根据上述例子不难看出，我们要入队的时候首先要确保队尾元素要比想要入队的元素小，然后才能入队，否则的话就一直循环让尾部元素出队，直到能够满足单调性为止。

单调队列的应用

求区间的最值问题。下面写的两个例题都是这个用处。
优化dp，我现在能接触到的就是一个用单调队列优化多重背包的一个题，但是那个题我学了这个东西之后还是不理解为什么可以那么做。例题如下：宝物筛选

单调队列的一些例题

A. Sliding Window

题意

给出一个含有 $n$ 个整数的序列 $a$ ，给出滑动窗口长度 $k$ ，窗口从序列最左端滑动到序列最右端，问滑动过程中每个时刻窗口中最大值和最小值是多少。

思路

一道很经典的单调队列的模板题，用于解决定长区间的最大最小值。我们可以维护两个单调队列，一个是单调递增的，一个是单调递减的。因为两种情况类似，我们考虑一下求窗口中最大值的方案。

求最大值我们用的是单调递减的序列，这样就能够保证每次队首的就是答案，但是，这是为什么呢？我们来考虑一下，因为这是一个单调递减的序列，那么我们每次序列元素入队的时候，我们就去看当前队尾的元素是不是要比他大，如果比他还小，那么我们就直接将队尾元素出队，因为这时候要入队的元素（已经被窗口覆盖了）已经比他大了，那么在接下来的窗口中，肯定就没他什么事了，因为它一定不是最大的，那么如果一直将队尾元素出队到加入入队元素后还继续能保持队列的单调性了，但是这个元素还不是在队首，这就说明，队首的元素还是要比他大的（单调性易得）。

所以这时候队首元素就是这个窗口中最大的了吗？也还不能确定，因为我们还不能确保这个队首元素就在窗口中，因此我们需要看看这个元素的位置和当前入队元素的位置之差是不是要比窗口长度大了，如果大于窗口长度，那么就说明队首元素已经不在窗口了，我们就将队首元素出队，最后输出队首元素就能确保它既在窗口中，又是窗口中所有元素的最大值了！

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=1000005;
int n,k;
int head,tail,a[maxn];
struct node
{
	int pos,value;
}q[maxn];
void getmax()
{
	head=tail=0;
	for(int i=1;i<=n;i++)
	{
		while(head!=tail&&i-q[head].pos>=k) head++;
		while(head!=tail&&a[i]<=q[tail-1].value) tail--;
		q[tail].value=a[i],q[tail++].pos=i;
		if(i>=k) printf("%d ",q[head].value);
	}
	putchar('\n');
	for(int i=1;i<=n;i++) q[i].value=q[i].pos=0;
}
void getmin()
{
	head=tail=0;
	for(int i=1;i<=n;i++)
	{
		while(head!=tail&&i-q[head].pos>=k) head++;
		while(head!=tail&&a[i]>=q[tail-1].value) tail--;
		q[tail].value=a[i],q[tail++].pos=i;
		if(i>=k) printf("%d ",q[head].value);
	}
}
int main()
{
	scanf("%d%d",&n,&k);
	for(int i=1;i<=n;i++)
	{
	 	scanf("%d",&a[i]);
	}
	getmax();
	getmin();
	return 0;
}

B. Max Sum of Max-K-sub-sequence

题意

给定长度为 $n$ 的整数循环序列 $a$ ，也就是$a[1],a[2],\cdots,a[n],a[1]\cdots$ 这样的序列，问最大连续长度为 $k$ 的连续子区间的序列和最大为多少，并且输出这个区间的左右坐标。

思路

我们把这道题转换一下，我们先处理好前缀和，好比我们要求 $a[1],a[2],a[3]$ 的序列和，那么也就是 $sum[3]-sum[0]$ ，因此我们在求这个题的时候就可以循环遍历 $1\sim{n-k+1}$ ，求长度为 $k$ 的定长区间中前缀和数组的最小值即可。但是我们要注意前缀和数组要处理到 $n-k+1$ 。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int inf=1000000;
const int maxn=200005;
int t;
int n,k,a[maxn],sum[maxn];
int head,tail;
struct node
{
	int pos,value;
}q[maxn];
int ans,l,r;
int main()
{
//	freopen("test.in","r",stdin);
	scanf("%d",&t);
	while(t--)
	{
		l=r=0;
		head=tail=0;
		ans=-inf;
		scanf("%d%d",&n,&k);
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&a[i]);
			sum[i]=sum[i-1]+a[i];
		}
		for(int i=n+1;i<=n+k-1;i++)
		{
			sum[i]=sum[i-1]+a[i-n];
		}
		for(int i=1;i<=n+k-1;i++)
		{
			while(head!=tail&&i-q[head].pos>k) head++;
			while(head!=tail&&sum[i-1]<=q[tail-1].value) tail--;
			q[tail].pos=i-1,q[tail++].value=sum[i-1];
//			if(i!=q[head].pos)
//			{ 
				int p=sum[i]-q[head].value;
				if(p>ans)
				{
					ans=p;
					int k=q[head].pos+1;
					k>n?l=k%n:l=k;
					i>n?r=i%n:r=i;
				}
//			}
		}
		printf("%d %d %d\n",ans,l,r);
		for(int i=1;i<=n+k-1;i++) q[i].pos=q[i].value=-inf;
	}
	return 0;
}

单调栈(Monotone stack)

单调增或单调减的栈，跟单调队列差不多，但是只用到它的一端。

理解

单调栈也是在普通栈的基础上加了单调性，一般是用从栈底到栈顶的单调性来命名，好比从栈底到栈顶是单调递增的，那么他就是单调增的栈。跟单调队列一样，他的入栈规则也是要不破坏单调性，因此一个单调递增的栈如果有元素要入栈，如果他比栈顶的元素还要大，就可以直接入栈，如果他比栈顶的元素小，那么就要将栈顶的元素一直出栈到比要入栈元素小为止。如果序列为 $[2,3,1,5,4,7]$，要加入单调递增栈中，过程如下。PS：注意从左到右对应栈底到栈顶。

栈中的元素	关于元素进出的备注
2	元素2压入栈中
2，3	3大于2，压入栈中
1	1小于3、2，因此全部弹出将1入栈
1，5	5大于1，压入栈中
1，4	4比5小，比1大，弹出5，压入4
1，4，7	7大于4，压入栈中

根据上述描述不难看出，其实单调栈就是单调队列的半部分，他能完成的任务理论上单调队列都能够完成，但是有些时候不需要麻烦的去维护单调队列只需要维护单调栈即可完成。

单调栈的应用

确定一个元素的左边区间第一个比它大的元素，第一个比它小的元素
确定右边区间第一个比他大or比他小的元素（根据单调性来看）
确定这个元素是否是一定区间内的最值，或者确定以他为最值的区间长度

单调栈的一些例题

A. 单调栈模板

题意

给出含有 $n$ 个整数的序列 $a$ ，定义 $f(i)$ 为第 $i$ 个元素后第一个大于 $a_i$ 的下标，求 $f(1)\cdots f(n)$

思路

直接就是模板，对应了上述应用里的第二个。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=3000005;
int n,a[maxn];
int stack[maxn];
int top,ans[maxn];
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
	}
	a[0]=1e9+5;
	for(int i=1;i<=n;i++)
	{ 
		while(top>=0&&a[i]>a[stack[top]])
		{
			ans[stack[top]] = i;
			top--;
		}
		stack[++top]=i;
	}
	while(top)
	{
		ans[stack[top]]=0;
		top--;
	}
	for(int i=1;i<=n;i++)
	{
		printf("%d ",ans[i]);
	}
	return 0;
}

B. 发射站

题意

某地有 $N$ 个能量发射站排成一行，每个发射站 $i$ 都有不相同的高度 $H_i$，并能向两边（两端的发射站只能向一边）同时发射能量值为 $V_i$ 的能量，发出的能量只被两边最近的且比它高的发射站接收。计算出接受能量最多的发射站接受的能量为多少。

思路

维护一个单调递减栈，一个元素新加进来如果是大于栈顶元素的话，那么栈顶元素出栈，并给入栈元素加上能量值。如果不大于栈顶元素的话，就将栈顶元素加上发射能量，然后将元素入栈。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=1000005;
int n,h[maxn],v[maxn];
int stack[maxn],top,ans;
int f[maxn];
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d%d",&h[i],&v[i]);
	}
	for(int i=1;i<=n;i++)
	{
		while(top>=0&&h[i]>h[stack[top]])
		{
			f[i]+=v[stack[top]];
			top--;
		}
		f[stack[top]]+=v[i];
		stack[++top]=i;
	}
	for(int i=1;i<=n;i++) ans=max(ans,f[i]);
	printf("%d",ans);
	return 0; 
}

C. 音乐会的等待

题意

给出一段序列 $a$ 代表 $n$ 个人，在一个区间 $[l,r]$ 如果区间内没有大于 $min(a[i],a[r])$ 的那么两个人可以相互看到。问这个序列中有多少对人可以相互看到。

思路

我们可以维护一个单调递减栈，然后分情况讨论一下。

如果要入栈元素大于当前元素，那么当前元素和入栈元素是可以相互看见的，因为这是找了左边区间第一个比它小的元素了，然后因为这是一个单调递减栈，所以我们可以一直出栈比入栈元素小的元素，可以发现这些都是可以互相看见的。而且最终的栈顶元素和要入栈元素也是可以看见的。
如果入栈元素小于当前元素，他可以和栈顶元素看见，而不能和后面的人看见，因为栈顶元素挡住他了。
如果入栈元素和当前元素高度相同，那么他们俩其实是等效的，如果有人比他们高，其实是可以直接看见两个，所以我们只需要将他们看成一个结构体，记录他们的数量和高度即可，每次统计的时候加上数量就行。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;
typedef long long ll;
const int maxn=500005;
int n;
int h[maxn];
ll ans;
struct node
{
	ll cnt; // num 
	ll p; //height
}stack[maxn];
int top;
int main()
{
//	freopen("test.in","r",stdin);
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&h[i]);
	}
	for(int i=1;i<=n;i++)
	{
		node temp;
		temp.cnt=1;
		temp.p=h[i];
		while(top>=0&&h[i]>stack[top].p)
		{
			ans+=stack[top].cnt;
			top--;
		}
		if(h[i]==stack[top].p)
		{
			ans+=stack[top].cnt;
			temp.cnt+=stack[top].cnt;
			top--;
		}
		stack[++top].cnt=temp.cnt;
		stack[top].p=temp.p;
		if(top!=0) ans+=1;
	}
	printf("%lld",ans);
}