现在的位置: 首页 > 综合 > 正文

五种数据结构解HNOI 营业额统计

2012年09月22日 ⁄ 综合 ⁄ 共 14556字 ⁄ 字号 评论关闭

1588: [HNOI2002]营业额统计

Time Limit: 5 Sec  Memory Limit: 162 MB
Submit: 2572  Solved: 773
[Submit][Status][Discuss]

Description

营业额统计 Tiger最近被公司升任为营业部经理,他上任后接受公司交给的第一项任务便是统计并分析公司成立以来的营业情况。 Tiger拿出了公司的账本,账本上记录了公司成立以来每天的营业额。分析营业情况是一项相当复杂的工作。由于节假日,大减价或者是其他情况的时候,营业额会出现一定的波动,当然一定的波动是能够接受的,但是在某些时候营业额突变得很高或是很低,这就证明公司此时的经营状况出现了问题。经济管理学上定义了一种最小波动值来衡量这种情况: 该天的最小波动值 当最小波动值越大时,就说明营业情况越不稳定。 而分析整个公司的从成立到现在营业情况是否稳定,只需要把每一天的最小波动值加起来就可以了。你的任务就是编写一个程序帮助Tiger来计算这一个值。 第一天的最小波动值为第一天的营业额。  输入输出要求

Input

第一行为正整数 ,表示该公司从成立一直到现在的天数,接下来的n行每行有一个正整数 ,表示第i天公司的营业额。

Output

输出文件仅有一个正整数,即Sigma(每天最小的波动值) 。结果小于2^31 。

Sample Input

6
5
1
2
5
4
6

Sample Output

12

HINT

结果说明:5+|1-5|+|2-1|+|5-5|+|4-5|+|6-5|=5+4+1+0+1+1=12

 

首先这题的算法很简单,就是找第i个数与前i-1个数绝对值差值最小的数字,相减,也就是只要在前i个数里面找到前驱和后继就可以了。

数据结构可以选用线性的,也可以选用树型的。。

线性表也能水过,大概900ms左右。。。

而树型的数据结构则效率相当之快,我用了五种树型数据结构来写这题。。

Treap树148ms, 线段树400ms, splay树168ms,递归的 AVL树192ms, SBT树192ms..

数据结构的选用要充分考虑三个方面

1.时间开销,

2.空间开销

3.编程复杂度

从时间角度来说,采用随机化算法的Treap树效率最高,线段树开销较大,其它的树如上所示。

从空间开销上来看,我采用的是数组,不高。。2000kb 到4000kb左右。。

从编程复杂度上来看, Treap树,线段树编程较简单。。AVL树如果写非递归的,则有点麻烦。 SBT 树还好。。

题目地址:http://www.zybbs.org/JudgeOnline/problem.php?id=1588

最后,我想说的是,此题的数据有问题,有两组数组,少一个数,输入的数先赋值为0,否则坑死你。

代码写的比较戳。。。。

SBT 版本。。

View Code

/**************************************************************
Problem: 1588
User: 314911229
Language: C++
Result: Accepted
Time:192 ms
Memory:6552 kb
***************************************************************
*/


#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include <time.h>

/*
非递归插入时,更新遇到问题,还要写个递归的更新函数,
蛋疼。。
与其这样,我不如写递归式的插入。
*/

using namespace std;

int size[400000], value[500000], num[400000];
int left[50000], right[40000], pf[40000];
int yy[40000], root;
int flag = 0;

void Left_Rotate( int t )
{
int k = left[t];
left[t] = right[k];
if( right[k] )
pf[right[k]] = t;
right[k] = t;
if( pf[t] )
{
if( left[pf[t]] == t )
left[pf[t]] = k;
else
right[pf[t]] = k;
}
pf[k] = pf[t];
pf[t] = k;
if( pf[k] == 0 )
root = k;
size[k] = size[t];
size[t] = size[left[t]] + size[right[t]] + 1;
}

void Right_Rotate( int t )
{
int k = right[t];
right[t] = left[k];
if( left[k] )
pf[left[k]] = t;
left[k] = t;
if( pf[t] )
{
if( left[pf[t]] == t )
left[pf[t]] = k;
else
right[pf[t]] = k;
}
pf[k] = pf[t];
pf[t] = k;
if( pf[k] == 0 )
root = k;
size[k] = size[t];
size[t] = size[left[t]] + size[right[t]] + 1;
}

void maintain( int x )
{
if( size[left[x]] < size[left[right[x]]] )
{
Left_Rotate( right[x] );
Right_Rotate( x );
}
if( size[left[x]] < size[right[right[x]]] )
{
Right_Rotate( x );
}
if( size[right[x]] < size[left[left[x]]] )
{
Left_Rotate( x );
}
if( size[right[x]] < size[right[left[x]]] )
{
Right_Rotate( left[x] );
Left_Rotate( x );
}
}


void insert(int p, int n, int ft, int flag)
{
if( !p || !root)
{
if( flag == 0 )
root = n;
else if( flag == 1 )
right[ft] = n;
else
left[ft] = n;
left[n] = 0;
right[n] = 0;
pf[n] = ft;
size[n] = 1;
return;
}
if ( p > n )
{
if( !left[p] )
flag = -1;
insert(left[p], n, p, flag);
}
else if( p < n )
{
if( !right[p] )
flag = 1;
insert(right[p], n, p, flag);
}
else if( p == n )
{
num[n]++;
return;
}
size[p] = size[left[p]] + size[right[p]] + 1;
maintain(p);
}


void preordertravel(int p)
{
if ( p ) {
printf("%d 的 父亲节点是 %d, 大小为%d\n", p, pf[p],size[p]);
preordertravel(left[p]);
preordertravel(right[p]);
}
}

int Get_Max( int n )
{
int t = n, p;
while( t )
{
p = t;
t = right[t];
}
return p;
}

int Get_Min( int n)
{
int t = n, p;
while( t )
{
p = t;
t = left[t];
}
return p;
}

//求后继
int Get_Next( int n )
{
if( num[n] != 0 ) //有这个值已经出现
return n;
if( right[n]) //如果它有右孩子
{
if( left[right[n]])
return Get_Min(left[right[n]]);
else
return right[n];
}
int p = n;
while( p )
{
if( p > n )
return p;
p = pf[p];
}
return 0;//如果没有后继
}

int Get_Prev( int n )
{
int p = n;
if( num[n] != 0 )
return n;
if( left[n] )
return Get_Max(left[n]);
while( p )
{
if( p < n )
return p;
p = pf[p];
}
return 0;
}
int main( )
{
int N;
// srand(time(NULL));
while ( scanf("%d", &N) != EOF )
{
root = 0;
yy[0] = 0;
for( int i = 1; i <= N; i++)
{
scanf("%d",&value[i]);
yy[i] = value[i];
}
int sum = 0;
sort(yy + 1, yy + N + 1);
int cnt = unique(yy + 1, yy + N + 1) - yy - 1;
for( int i = 1; i <= N; i++)
{
value[i] = lower_bound(yy + 1, yy + cnt + 1, value[i]) - yy;
insert(root, value[i],0, 0);
// printf("%d %d\n", value[i], root);
int nex = Get_Next(value[i]);
int prev = Get_Prev(value[i]);
//printf("%d %d %d %d\n", prev, nex, yy[prev], yy[nex]);
if( nex == 0 && prev == 0 ) //如果前驱后继皆为零
sum += yy[value[i]];
else if( nex == 0 ) //如果后继为零
sum += abs(yy[value[i]] - yy[prev]);
else if( prev == 0 )
sum += abs(yy[value[i]] - yy[nex]);
else
sum += min(abs(yy[value[i]] - yy[nex]), abs(yy[value[i]] - yy[prev]));
}
printf("%d\n", sum);
}
return 0;
}

AVL版本:

View Code

/**************************************************************
Problem: 1588
User: 314911229
Language: C++
Result: Accepted
Time:192 ms
Memory:1468 kb
***************************************************************
*/



#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <algorithm>
using namespace std;

typedef struct BBST
{
int data;
int high;//puts树的高度
BBST *rchild, *lchild, *pf;
}*BST;

int height( BST p )
{
if ( p == NULL )
return -1;
else
return p->high;
}

//putsL
BST singlerotatewithleft( BST &p)
{
BST q; //puts新的头结点
q = p->lchild;
p->lchild = q->rchild;
if( q->rchild )
q->rchild->pf = p;
q->rchild = p;
q->pf = p->pf;
p->pf = q;
p->high = max(height(p->rchild), height(p->lchild)) + 1;
q->high = max(height(q->rchild), height(q->lchild)) + 1;
return q;
}

BST singlerotatewithright(BST &p)
{

BST q;
q = p->rchild;
p->rchild = q->lchild;
if( q->lchild )
q->lchild->pf = p;
q->lchild = p;
q->pf = p->pf;
p->pf = q;
p->high = max(height(p->rchild), height(p->lchild)) + 1;
q->high = max(height(q->rchild), height(q->lchild)) + 1;
return q;
}

//putsLR
BST doublerotatewithleft( BST &p)
{
BST q;
q = singlerotatewithright(p->lchild);
p->lchild = q;
if( q )
q->pf = p;
return singlerotatewithleft(p);
}

//putsRL

BST doublerotatewithright( BST &p)
{
BST q;
q = singlerotatewithleft(p->rchild);
p->rchild = q;
if( q )
q->pf = p;
return singlerotatewithright(p);
}


BST creat_AVL_tree(BST &p, BST &q, BST father)
{
if ( p == NULL ) {
p = q;
p->pf = father;
}
else
if ( p->data > q->data ) {
p->lchild = creat_AVL_tree(p->lchild, q, p);
if ( height(p->lchild) - height(p->rchild) == 2 ) {
if (q->data < p->lchild->data ) {
p = singlerotatewithleft(p);
}
else {
p = doublerotatewithleft(p);
}
}
}
else
if( p->data <= q->data )
{
p->rchild = creat_AVL_tree(p->rchild, q, p);
if ( height(p->rchild) - height(p->lchild) == 2 ) {
if ( q->data >= p->rchild->data ) {
p = singlerotatewithright(p);
}
else {
p = doublerotatewithright(p);
}
}
}
p->high = max(height(p->lchild), height(p->rchild)) + 1 ;
return p;
}
void preordertravel(BST p)
{
if ( p ) {
if ( p->pf != NULL)
printf("%d 的 父亲节点是 %d\n", p->data, p->pf->data);
else if ( p->pf == NULL )
printf("%d 的 父亲节点是 空\n", p->data);
preordertravel(p->lchild);
preordertravel(p->rchild);
}
}



BST Get_Max( BST n )
{
BST t = n, p;
while( t != NULL )
{
p = t;
t = t->rchild;
}
return p;
}

BST Get_Min( BST n)
{
BST t = n, p;
while( t != NULL )
{
p = t;
t = t->lchild;
}
return p;
}

//求后继
BST Get_Next( BST n )
{
int f = 0;
if(n->rchild != NULL) //如果它有右孩子
{
if( n->rchild->lchild != NULL)
return Get_Min(n->rchild->lchild);
else
return n->rchild;
}
BST p = n;
while( p != NULL )
{
if( p->data >= n->data && f != 0 )
return p;
f++;
p = p->pf;
}
return NULL;//如果没有后继
}

BST Get_Prev( BST n )
{
int f = 0;
BST p = n;
if( n->lchild != NULL)
return Get_Max(n->lchild);
while( p != NULL )
{
if( p->data <= n->data && f != 0 )
return p;
p = p->pf;
f++;
}
return NULL;
}

BST AVL_binary_find(BST p, BST q)
{

if ( p == NULL )
return NULL;
if ( p == q )
return p;
if ( p->data > q->data && p->lchild != NULL)
return AVL_binary_find(p->lchild, q);
else if (p->data <= q->data && p->rchild != NULL)
return AVL_binary_find(p->rchild, q);
}

void debug( )
{
#ifdef P
freopen("in.txt", "r", stdin);
freopen("out1.txt", "w", stdout);
#endif


}

int main( )
{
int N, t;
while ( scanf("%d", &N) != EOF ) {
BST p = NULL;
int sum = 0;
for( int i = 1; i <= N; i++) {
t = 0;
scanf("%d", &t);
BST q = new BBST;
q->data = t;
q->rchild = NULL;
q->lchild = NULL;
q->high = 0;
q->pf = NULL;
p = creat_AVL_tree(p,q, NULL);
BST nex = Get_Next(q);
BST prev = Get_Prev(q);
if( nex == NULL && prev == NULL ) //如果前驱后继皆为零
sum += t;
else if( nex == NULL ) //如果后继为零
sum += abs(t - prev->data);
else if( prev == NULL )
sum += abs(t - nex->data);
else
sum += min(abs(t - nex->data), abs(t- prev->data));
}
printf("%d\n", sum);

}
return 0;
}

Treap树版本

View Code

/**************************************************************
Problem: 1588
User: 314911229
Language: C++
Result: Accepted
Time:148 ms
Memory:3544 kb
***************************************************************
*/

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
#include <time.h>

/*
Treap 树满足两个条件。。
1.是二叉排序树。。
2.是最小优先堆
*/

using namespace std;

int value[100000];
int yy[100000];
int left[100000], right[100000], pf[100000];
int num[100000]; //该数出现次数
int pri[100000]; //该数优先值
int root;
//右旋
inline void Right_Rotate( int n )
{
int m = pf[n];
left[m] = right[n];
pf[right[n]] = m;
right[n] = m;
if(left[pf[m]] == m )
left[pf[m]] = n;
else
right[pf[m]] = n;
pf[n] = pf[m];
pf[m] = n;
}

//左旋
inline void Left_Rotate( int n )
{
int m = pf[n];
right[m] = left[n];
pf[left[n]] = m;
left[n] = m;
if(left[pf[m]] == m )
left[pf[m]] = n;
else
right[pf[m]] = n;
pf[n] = pf[m];
pf[m] = n;
}

void Rotate( int n )
{
while( pri[n] < pri[pf[n]] )
{
if( left[pf[n]] == n )
Right_Rotate( n );
else
Left_Rotate( n );
if( pf[n] == -1 )
break;
}
}


void insert(int n)
{
int t = root;
if( root == -1 )
{
root = n;
left[root] = -1;
right[root] = -1;
pf[root] = -1;
return;
}
while( 1 )
{
if( t > n )
{
if( left[t] == -1 )
{
left[t] = n;
pf[n] = t;
left[n] = -1;
right[n] = -1;
pri[n] = rand( ) % 10000; //随便生成一个优先值
Rotate(n); //然后调整树,使其成为treap树
return;
}
t = left[t];
}
else if( t < n )
{
if( right[t] == -1)
{
right[t] = n;
pf[n] = t;
left[n] = -1;
right[n] = -1;
pri[n] = rand( ) % 10000; //随便生成一个优先值
Rotate(n); //然后调整树,使其成为treap树
return;
}
t = right[t];
}
else
{
num[n]++;
return;
}

}
}

int Get_Max( int n )
{
int t = n, p;
while( t != -1 )
{
p = t;
t = right[t];
}
return p;
}

int Get_Min( int n)
{
int t = n, p;
while( t != -1 )
{
p = t;
t = left[t];
}
return p;
}

//求后继
int Get_Next( int n )
{
if( num[n] != 0 ) //有这个值已经出现
return n;
if( right[n] != -1 ) //如果它有右孩子
{
if( left[right[n]] != -1 )
return Get_Min(left[right[n]]);
else
return right[n];
}
int p = n;
while( p != -1 )
{
if( p > n )
return p;
p = pf[p];
}
return 0;//如果没有后继
}

int Get_Prev( int n )
{
int p = n;
if( num[n] != 0 )
return n;
if( left[n] != -1 )
return Get_Max(left[n]);
while( p != -1 )
{
if( p < n )
return p;
p = pf[p];
}
return 0;
}

void remove( int x, int p)
{
if( p != -1 )
{
if( x > yy[p] )
remove(x, right[p]);
else if( x < yy[p] )
remove(x, left[p]);
else
{
if( left[p] == -1 && right[p] == -1 )
{
if(left[pf[p]] == p )
{
left[pf[p]] = -1;
pf[p] = -1;
}
else
{
right[pf[p]] = -1;
pf[p] = -1;
}
}
if( pri[left[p]] < pri[right[p]] )
{
Left_Rotate(p);
remove(x, right[p]);
}
else
{
Right_Rotate(p);
remove(x, left[p]);
}
}
}
}

void debug( )
{
#ifdef P
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif


}

void preordertravel(int p)
{
if ( p != -1 ) {
printf("%d 的 父亲节点是 %d\n", p, pf[p]);
preordertravel(left[p]);
preordertravel(right[p]);
}
}

int main( )
{
int N;
// srand(time(NULL));
while ( scanf("%d", &N) != EOF )
{
root = -1;
yy[0] = 0;
for( int i = 1; i <= N; i++)
{
scanf("%d",&value[i]);
yy[i] = value[i];
}
int sum = 0;
sort(yy + 1, yy + N + 1);
int cnt = unique(yy + 1, yy + N + 1) - yy - 1;
for( int i = 1; i <= N; i++)
{
value[i] = lower_bound(yy + 1, yy + cnt + 1, value[i]) - yy;
insert(value[i]);
int nex = Get_Next(value[i]);
int prev = Get_Prev(value[i]);
printf("%d %d %d %d\n", prev, nex, yy[prev], yy[nex]);
if( nex == 0 && prev == 0 ) //如果前驱后继皆为零
sum += yy[value[i]];
else if( nex == 0 ) //如果后继为零
sum += abs(yy[value[i]] - yy[prev]);
else if( prev == 0 )
sum += abs(yy[value[i]] - yy[nex]);
else
sum += min(abs(yy[value[i]] - yy[nex]), abs(yy[value[i]] - yy[prev]));
}
printf("%d\n", sum);
}
return 0;
}

Splay版本

View Code

/**************************************************************
Problem: 1588
User: 314911229
Language: C++
Result: Accepted
Time:168 ms
Memory:2372 kb
***************************************************************
*/

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
#include <time.h>

using namespace std;

int left[50000], right[50000], pf[50000];
int value[100000];
int num[50000]; //记录该数出现次数
int yy[100000];
int root;

//右旋
inline void zig( int n )
{
int m = pf[n];
left[m] = right[n];
pf[right[n]] = m;
right[n] = m;
if(left[pf[m]] == m )
left[pf[m]] = n;
else
right[pf[m]] = n;
pf[n] = pf[m];
pf[m] = n;
}

//左旋
inline void zag( int n )
{
int m = pf[n];
right[m] = left[n];
pf[left[n]] = m;
left[n] = m;
if(left[pf[m]] == m )
left[pf[m]] = n;
else
right[pf[m]] = n;
pf[n] = pf[m];
pf[m] = n;
}

inline int splay(int n, int p)
{
while( pf[n] != p )
{
int px = pf[n];
int pfather = pf[px];
if( pfather == p )
{
if( n == left[px])
zig(n);
else
zag(n);

}
else
{
if( left[pfather] == px )
{
if( left[px] == n )
{
zig(px);
zig(n);
}
else
{
zag(n);
zig(n);
}
}
else if(right[pfather] == px)
{
if( right[px] == n )
{
zag(px);
zag(n);
}
else
{
zig(n);
zag(n);
}
}
}
}
return n;
}

void insert( int n )
{
int t = root;
if( root == -1 )
{
root = n;
left[root] = -1;
right[root] = -1;
pf[root] = -1;
root = n;
return;
}
while( 1 )
{
if( t > n )
{
if( left[t] == -1 )
{
left[t] = n;
pf[n] = t;
left[n] = -1;
right[n] = -1;
root = splay(n,-1);
return;
}
t = left[t];
}
else if( t < n )
{
if( right[t] == -1)
{
right[t] = n;
pf[n] = t;
left[n] = -1;
right[n] = -1;
root = splay(n,-1);
return;
}
t = right[t];
}
else
{
root = splay(n,-1);
num[n]++;
return;
}

}
}


int get_Min( int n )
{
int t = n, p;
while( t != -1 )
{
p = t;
t = left[t];
}
return p;
}

int get_Max( int n )
{
int t = n, p;
while( t != -1 )
{
p = t;
t = right[t];
}
return p;
}

int get_next( int n )
{
if( num[n] != 0 )
return n;
else if( right[n] == -1 )
return 0;
else if( left[right[n]] != -1 )
return get_Min(left[right[n]]);
else
return right[n];
}

int get_prev( int n)
{
if( num[n] != 0 )
return n;
else if( left[n] == -1 )
return 0;
else if(right[left[n]] != -1 )
return get_Max(right[left[n]]);
else
return left[n];
}

int main( )
{
int N;
const int inf = 0x7f7f7f;
while ( scanf("%d", &N) != EOF )
{
yy[0] = 0;
root = -1;//根结点
int sum = 0;
for( int i = 1; i <= N; i++)
{
scanf("%d", &value[i]);
yy[i] = value[i];
}
sort(yy + 1, yy + N + 1);
int cnt = unique(yy + 1,yy + N + 1) - yy - 1;
for( int i = 1; i <= N; i++)
{
value[i] = lower_bound(yy + 1, yy + cnt + 1, value[i]) - yy;
insert(value[i]);
int nex = get_next(value[i]);
int prev = get_prev(value[i]);
if( nex == 0 && prev == 0 ) //如果前驱后继皆为零
sum += yy[value[i]];
else if( nex == 0 ) //如果后继为零
sum += abs(yy[value[i]] - yy[prev]);
else if( prev == 0 )
sum += abs(yy[value[i]] - yy[nex]);
else
sum += min(abs(yy[value[i]] - yy[nex]), abs(yy[value[i]] - yy[prev]));
}
printf("%d\n", sum);
}
return 0;
}

线段树版本

View Code

/**************************************************************
Problem: 1588
User: 314911229
Language: C++
Result: Accepted
Time:400 ms
Memory:10652 kb
***************************************************************
*/

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <functional>
#include <map>
#include <set>
#include <time.h>
#include <iostream>
#include <fstream>

using namespace std;

struct node
{
int l, r;
int maxn;
int minn;
}T[100000];

void debug( )
{
#ifdef P
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif

}
const long long inf = 0x7f7f7f7f;
int value[1000000];
int yy[1000000];

int fmaxx = 0, fminn = inf;

void build(int l, int r, int root)
{
int mid = (l + r) / 2;
T[root].l = l, T[root].r = r, T[root].maxn = -inf, T[root].minn = inf;
if( l == r )
return;
build(l, mid, root * 2);
build(mid + 1, r, root * 2 + 1);
}

void insert( int num, int value, int root)
{
int mid = (T[root].l + T[root].r ) / 2;
if(num == T[root].l && num == T[root].r)
{
T[root].maxn = value;
T[root].minn = value;
return;
}
if( mid >= num )
insert(num, value, root * 2);
else
insert(num, value, root * 2 + 1);
T[root].maxn = max(T[root * 2].maxn , T[root * 2 + 1].maxn);
T[root].minn = min(T[root * 2].minn , T[root * 2 + 1].minn);
}

void query_max( int a, int b, int root)
{
int mid = (T[root].l + T[root].r ) / 2;
if( T[root].l >= a && T[root].r <= b)
{
if(T[root].maxn > fmaxx )
fmaxx = T[root].maxn;
return;
}
if( mid >= b )
query_max(a, b, root * 2);
else if( mid < a)
query_max(a, b, root * 2 + 1);
else
{
query_max(a, mid, root * 2);
query_max(mid + 1, b, root * 2 + 1);

}
}

void query_min( int a, int b, int root)
{
int mid = (T[root].l + T[root].r ) / 2;
if( T[root].l >= a && T[root].r <= b)
{
if( T[root].minn < fminn )
fminn = T[root].minn;
return;
}
if( mid >= b )
query_min(a, b, root * 2);
else if( mid < a)
query_min(a, b, root * 2 + 1);
else
{
query_min(a, mid, root * 2);
query_min(mid + 1, b, root * 2 + 1);

}
}

int main( )
{
int N;
while ( scanf("%d", &N) != EOF)
{
memset(T, 0, sizeof(T));
memset(yy, 0, sizeof(yy));
memset(value, 0, sizeof(value));
for( int i = 1; i <= N; i++)
{
scanf("%d", &value[i]);
yy[i] = value[i];
}

抱歉!评论已关闭.