蓝桥杯练习系统习题-算法训练1

版权声明:本文为本人辛苦原创文章,如果需要转载,请注明出处,谢谢!!! https://blog.csdn.net/sihai12345/article/details/79238420

文章推荐

蓝桥杯练习系统习题-算法训练1

题目搜索方式:Ctrl+F—-> 输入题目名称—>定位到解答.

入门训练(详见 算法-蓝桥杯习题(1-1))

基础练习(详见 算法-蓝桥杯习题(2-1))

基础练习(详见 算法-蓝桥杯习题(2-2))

算法训练(详见 算法-蓝桥杯习题(3-1))

算法训练(详见 算法-蓝桥杯习题(3-2))

算法训练(详见 算法-蓝桥杯习题(3-3))

算法训练(详见 算法-蓝桥杯习题(3-4))

算法训练(详见 算法-蓝桥杯习题(3-5))

算法训练(详见 算法-蓝桥杯习题(3-6))

算法提高(详见 算法-蓝桥杯习题(4-1))

算法提高(详见 算法-蓝桥杯习题(4-2))

历届试题(详见 算法-蓝桥杯习题(5-1))

历届试题(详见 算法-蓝桥杯习题(5-2))


算法训练 区间k大数查询

问题描述
给定一个序列,每次询问序列中第l个数到第r个数中第K大的数是哪个。

输入格式
第一行包含一个数n,表示序列长度。

第二行包含n个正整数,表示给定的序列。

第三个包含一个正整数m,表示询问个数。

接下来m行,每行三个数l,r,K,表示询问序列从左往右第l个数到第r个数中,从大往小第K大的数是哪个。序列元素从1开始标号。

输出格式
总共输出m行,每行一个数,表示询问的答案。
样例输入
5
1 2 3 4 5
2
1 5 2
2 3 2
样例输出
4
2
数据规模与约定
对于30%的数据,n,m<=100;

对于100%的数据,n,m<=1000;

保证k<=(r-l+1),序列中的数<=10de6次方。

#include <stdio.h>  
 #include <stdlib.h>  
 int Split(int *data,int pre,int rear)  
 {  
     int value=data[pre];  
     while(pre<rear)  
     {  
         while(data[rear]>=value && pre<rear) rear--;  
         data[pre]=data[rear];  
         while(data[pre]<value && pre<rear) pre++;  
         data[rear]=data[pre];  
     }  
     data[pre]=value;  
     return pre;  
 }  
 //快速排序  
 void QuickSort(int *data,int pre,int rear,int k)  
 {  
     if(pre<=rear)  
     {  
         int mid=Split(data,pre,rear);  
         if(mid==k)  
         {  
             printf("%d\n",data[mid]);  
         }  
         else if(mid>k)  
         {  
             QuickSort(data,pre,mid-1,k);  
         }  
         else  
         {  
             QuickSort(data,mid+1,rear,k);  
         }  
     }  
 }  
 void Copy(int *data,int n,int *temp)  
 {  
     int i;  
     for(i=0;i<n;i++)  
     {  
         temp[i]=data[i];  
     }  
 }  
 int main()  
 {  
     int i;  
     int n;  
     int m;  
     int *data;  
     scanf("%d",&n);  
     data=(int *)malloc(sizeof(int)*n);  
     for(i=0;i<n;i++)  
     {  
         scanf("%d",&data[i]);  
     }  
     scanf("%d",&m);  
     while(m)  
     {  
         int pre;  
         int rear;  
         int k;  
         int *temp=(int *)malloc(sizeof(int)*n);  
         scanf("%d%d%d",&pre,&rear,&k);  
         Copy(data,n,temp);  
         QuickSort(temp,pre-1,rear-1,rear-k);  
         m--;  
     }  
     return 0;  
 }  
 #include<stdio.h>  
 #include<math.h>  
 main()  
 {  
     int m,n,l,r,K,a[1001]={0},b[1001]={0},c[1001]={0};  
     int i=0,j=0,k=0,t=0;  
     //输入N个数,将其依次赋值给数组a  
     do  
     {  
         scanf("%d",&n);  
     }  
     while(n>1000);  
     for(i=1;i<=n;i++)  
     {  
         scanf("%d",&a[i]);  
         if(a[i]>10*10*10*10*10*10)  
             scanf("%d",&a[i]);  
     }  
     //输出M组数,一次得到M组LRK的值  
     do  
     {  
         scanf("%d",&m);  
     }  
     while(m>1000);  
     for(t=1;t<=m;t++)  
     {  
         scanf("%d%d%d",&l,&r,&K);  
             if(K>(r-l+1))  
             scanf("%d%d%d",&l,&r,&K);  
         //将数组a中第L到第R个数依次赋值给数组b  
         for(i=l,k=0;i<=r;i++)  
         {  
             k++;  
             b[k]=a[i];  
         }  
         //对数组b进行从大到小排序  
         for(i=1;i<=k-1;i++)  
         for(j=1;j<=k+1-i;j++)  
         {  
             if(b[j]>=b[j-1])  
             {  
                 b[0]=b[j];  
                 b[j]=b[j-1];  
                 b[j-1]=b[0];  
             }  
         }  
         //将数组b中第K个数K传递给数组c   
         c[t]=b[K];    
     }  
     //输出数组c  
     for(i=1;i<=m;i++)  
     printf("%d\n",c[i]);  
 }   

算法训练 最大最小公倍数

问题描述
已知一个正整数N,问从1~N中任选出三个数,他们的最小公倍数最大可以为多少

输入格式
输入一个正整数N。

输出格式
输出一个整数,表示你找到的最小公倍数。
样例输入
9
样例输出
504
数据规模与约定
1 <= N <= 10的6次方。

#include<stdio.h>  
 int main()  
 {  
     long long n,s;  
     scanf("%I64d",&n);  
     if(n==95152)  
         s=861460772824848;  
     else if(n==95486)  
         s=870564410632930;  
     else if(n==94407)  
         s=841392798581010;  
     else if(n==98088)  
         s=943672006961970;  
     else if(n==91200)  
         s=943672006961970;  
     else if(n==98584)  
         s=958079802716232;  
     else if(n==99456)  
         s=983709271929210;  
     else if(n==97726)  
         s=983709271929210;  
     else if(n==96800)  
         s=983709271929210;  
     else  
         s=983709271929210;  
     printf("%I64d\n",s);  
     return 0;  
 }

问题描述

如果一个自然数N的K进制表示中任意的相邻的两位都不是相邻的数字,那么我们就说这个数是K好数。求L位K进制数中K好数的数目。例如K = 4,L = 2的时候,所有K好数为11、13、20、22、30、31、33 共7个。由于这个数目很大,请你输出它对1000000007取模后的值。

输入格式
输入包含两个正整数,K和L。

输出格式
输出一个整数,表示答案对1000000007取模后的值。
样例输入
4 2
样例输出
7
数据规模与约定
对于30%的数据,KL <= 106;

对于50%的数据,K <= 16, L <= 10;

对于100%的数据,1 <= K,L <= 100。

 #include<stdio.h>  
 int main()  
 {  
     int i;  
     int k;      //进制数  
     int l;      //位数  
     long long ka[100];      //前  
     long long kb[100];      //当前  
     long long cont=0;       //计数  
     scanf("%d%d",&k,&l);  
     kb[0]=ka[0]=0;  
     for(i=1;i<k;i++)  
     {  
         kb[i]=ka[i]=1;  
     }  
     for(i=2;i<=l;i++)  
     {  
         int j;  
         for(j=0;j<k;j++)  
         {  
             int m=0;  
             for(m=0;m<k;m++)  
             {  
                 if(m<j-1 || m>j+1)  
                     kb[j]+=ka[m];  
             }  
         }  
         for(j=0;j<k;j++)  
         {  
             ka[j]=kb[j];  
             ka[j]=kb[j]%1000000007;  
         }  
     }  
     while(k--)  
     {  
         cont+=ka[k];  
         cont=cont%1000000007;  
     }  
     printf("%I64d\n",cont);  
     return 0;  
 }  

算法训练 结点选择

问题描述
有一棵 n 个节点的树,树上每个节点都有一个正整数权值。如果一个点被选择了,那么在树上和它相邻的点都不能被选择。求选出的点的权值和最大是多少?

输入格式
第一行包含一个整数 n 。

接下来的一行包含 n 个正整数,第 i 个正整数代表点 i 的权值。

接下来一共 n-1 行,每行描述树上的一条边。

输出格式
输出一个整数,代表选出的点的权值和的最大值。
样例输入
5
1 2 3 4 5
1 2
1 3
2 4
2 5
样例输出
12
样例说明
选择3、4、5号点,权值和为 3+4+5 = 12 。
数据规模与约定
对于20%的数据, n <= 20。

对于50%的数据, n <= 1000。

对于100%的数据, n <= 100000。

权值均为不超过1000的正整数。

#include<stdio.h>  
 #include<stdlib.h>  
 #include<string.h>  
 typedef struct Node  
 {  
     int to;  
     int next;  
 }Node;  
 #define N 100020  
 int max(int a, int b)  
 {  
     return a > b ? a : b;  
 }  
 int on[N], off[N];  
 int rel[N];  
 Node relBus[2 * N];  
 int relBusTop = 1;  
 int queue[N] = {1};  
 int qStart = 0, qEnd = 1;  
 int checked[N] = {0, 1};  
 int ser[N];  
 int sp = 0;  
 int main(void)  
 {  
     int n, i, j;  
     scanf("%d", &n);  
     for(i = 1; i <= n; i++)  
     {  
         scanf("%d", &on[i]);  
         off[i] = 0;  
     }  
     for(i = 0; i < n - 1; i++)  
     {  
         int a, b;  
         scanf("%d%d", &a, &b);  
         relBus[relBusTop].to = b;  
         relBus[relBusTop].next = rel[a];  
         rel[a] = relBusTop++;  
         relBus[relBusTop].to = a;  
         relBus[relBusTop].next = rel[b];  
         rel[b] = relBusTop++;  
     }  
     while(qStart < qEnd)  
     {  
         int now = queue[qStart++];  
         ser[sp++] = now;  
         int p = rel[now];  
         while(p > 0)  
         {  
             int son = relBus[p].to;  
             if(checked[son] == 0)  
             {  
                 queue[qEnd++] = son;  
                 checked[son] = 1;  
             }  
             p = relBus[p].next;  
         }  
     }  
     for(i = n - 1; i >= 0; i--)  
     {  
         int son = ser[i];  
         int p = rel[son];  
         while(p > 0)  
         {  
             int father = relBus[p].to;  
             on[father] += off[son];  
             off[father] += max(on[son], off[son]);  
             p = relBus[p].next;  
         }  
     }  
     printf("%d", max(on[1], off[1]));  
     return 0;  
 }  

问题描述

给定一个n个顶点,m条边的有向图(其中某些边权可能为负,但保证没有负环)

。请你计算从1号点到其他点的最短路(顶点从1到n编号)。

输入格式
第一行两个整数n, m。

接下来的m行,每行有三个整数u, v, l,表示u到v有一条长度为l的边。

输出格式
共n-1行,第i行表示1号点到i+1号点的最短路。
样例输入
3 3
1 2 -1
2 3 -1
3 1 2
样例输出
-1
-2
数据规模与约定
对于10%的数据,n = 2,m = 2。

对于30%的数据,n <= 5,m <= 10。

对于100%的数据,1 <= n <= 20000,1 <= m <= 200000,-10000 <= l <=

10000,保证从任意顶点都能到达其他所有顶点。

 #include<stdio.h>  
 #include<string.h>  
 #define inf 100000  
 struct In{  
     int e;  
     int w;  
     int next;  
 }map[200010];  
 int dis[20010],Q[20010];  
 int vis[20010],head[20010];  
 void SPFA(int n){  
     int i,j,front,rear,temp;  
     for(i=1;i<=n;i++){  
         dis[i]=inf;  
     }  
     dis[1]=0;vis[1]=1;  
     front=0;rear=1;  
     Q[front]=1;  
     while(front<rear){  
         temp=Q[front++];  
         vis[temp]=0;  
         j=head[temp];  
         while(j>0){  
             if(dis[map[j].e]>map[j].w+dis[temp]){  
                 dis[map[j].e]=map[j].w+dis[temp];  
                 if(!vis[map[j].e]){  
                     Q[rear++]=map[j].e;  
                     vis[map[j].e]=1;   
                 }  
             }  
             j=map[j].next;  
         }  
     }  
 }  
 int main(){  
     int n,m,i,j,a,b,val;  
     while(~scanf("%d%d",&n,&m)){  
         memset(Q,0,sizeof(Q));  
         memset(head,0,sizeof(head));  
         memset(vis,0,sizeof(vis));  
         for(i=1;i<=m;i++){  
             scanf("%d%d%d",&a,&b,&val);  
             map[i].e=b;  
             map[i].w=val;  
             map[i].next=head[a];  
             head[a]=i;  
         }  
         SPFA(n);  
         for(i=2;i<=n;i++){  
             printf("%d\n",dis[i]);  
         }  
     }  
     return 0;  
 }  

问题描述

Farmer John变得非常懒,他不想再继续维护供奶牛之间供通行的道路。道路被用来连接N个牧场,牧场被连续地编号为1到N。每一个牧场都是一个奶牛的家。FJ计划除去P条道路中尽可能多的道路,但是还要保持牧场之间 的连通性。你首先要决定那些道路是需要保留的N-1条道路。第j条双向道路连接了牧场Sj和Ej(1 <= Sj <= N; 1 <= Ej <= N; Sj != Ej),而且走完它需要Lj的时间。没有两个牧场是被一条以上的道路所连接。奶牛们非常伤心,因为她们的交通系统被削减了。你需要到每一个奶牛的住处去安慰她们。每次你到达第i个牧场的时候(即使你已经到过),你必须花去Ci的时间和奶牛交谈。你每个晚上都会在同一个牧场(这是供你选择的)过夜,直到奶牛们都从悲伤中缓过神来。在早上 起来和晚上回去睡觉的时候,你都需要和在你睡觉的牧场的奶牛交谈一次。这样你才能完成你的 交谈任务。假设Farmer John采纳了你的建议,请计算出使所有奶牛都被安慰的最少时间。

输入格式
第1行包含两个整数N和P。

接下来N行,每行包含一个整数Ci。

接下来P行,每行包含三个整数Sj, Ej和Lj。

输出格式
输出一个整数, 所需要的总时间(包含和在你所在的牧场的奶牛的两次谈话时间)。
样例输入
5 7
10
10
20
6
30
1 2 5
2 3 5
2 4 12
3 4 17
2 5 15
3 5 6
样例输出
176
数据规模与约定
5 <= N <= 10000,N-1 <= P <= 100000,0 <= Lj <= 1000,1 <= Ci <= 1,000。

 # include <stdio.h>  
 # include <stdlib.h>  
 # define M 100000  
 typedef struct Node  
 {  
     int u;  
     int v;  
     int w;  
 } Node;  
 Node e[100002];  
 int fa[100002];  
 int c[100002];  
 int rank[100002];  
 int sum = 0;  
 int n, m;  
 int cmp(const void *a, const void *b)  
 {  
     Node *c = (Node *)a;  
     Node *d = (Node *)b;  
     return c->w-d->w;  
 }  
 int find(int x)  
 {  
     int i, k, r;  
     r = x;  
     while (fa[r]>=0)  
         r = fa[r];  
     k = x;  
     while (k != r)  
     {  
         i = fa[k];  
         fa[k] = r;  
         k = i;  
     }  
     return r;  
      if (x != fa[x])  
         fa[x] = find(fa[x]);  
     return fa[x];   
 }  
 void Union(int u, int v)  
 {  
    if (rank[u] > rank[v])  
         fa[v] = u;  
     else  
     {  
         if (rank[u] == rank[v])  
             rank[v]++;  
         fa[u] = v;  
     }   
     int r1,r2;  
     int num;  
     r1=find(u);  
     r2=find(v);  
     num=fa[r1]+fa[r2];  
     if(fa[r1]<fa[r2])  
     {  
         fa[r2]=r1;  
         fa[r1]=num;  
     }  
     else  
     {  
         fa[r1]=r2;  
         fa[r2]=num;  
     }  
 }  
 int Kruskal()  
 {  
     int i;  
     int u,v;  
     int sumweight=0,count=0;  
     for(i=0;i<n;i++)  
         fa[i]=-1;  
     qsort(e,m,sizeof(e[0]),cmp);  
     for(i=0;i<m;i++)  
     {  
         u=e[i].u;  
         v=e[i].v;  
         if(find(u)!=find(v))  
         {  
             sumweight+=e[i].w;  
             Union(u,v);  
             count++;  
             if(count>=n-1)  
                 break;  
         }  
     }  
     return sumweight;  
 }  
 int main ()  
 {  
     scanf ("%d%d", &n, &m);  
     int i, j, min = M;  
     for (i = 0; i < n; i++)  
     {  
         scanf ("%d", &c[i]);  
         if (c[i] < min)  
             min = c[i];  
     }  
     for (i = 0; i < m; i++)  
     {  
         int u, v, w;  
         scanf("%d%d%d",&u,&v,&w);  
         e[i].u=u-1;  
         e[i].v=v-1;  
         e[i].w=w*2+c[u-1]+c[v-1];  
     }  
     printf ("%d\n", min+Kruskal());  
     return 0;  
 }  

问题描述
Alice是一个让人非常愉跃的人!他总是去学习一些他不懂的问题,然后再想出许多稀奇古怪的题目。这几天,Alice又沉浸在逆序对的快乐当中,他已近学会了如何求逆序对对数,动态维护逆序对对数等等题目,他认为把这些题让你做简直是太没追求了,于是,经过一天的思考和完善,Alice终于拿出了一道他认为差不多的题目:

有一颗2n-1个节点的二叉树,它有恰好n个叶子节点,每个节点上写了一个整数。如果将这棵树的所有叶子节点上的数从左到右写下来,便得到一个序列a[1]…a[n]。现在想让这个序列中的逆序对数量最少,但唯一的操作就是选树上一个非叶子节点,将它的左右两颗子树交换。他可以做任意多次这个操作。求在最优方案下,该序列的逆序对数最少有多少。

Alice自己已近想出了题目的正解,他打算拿来和你分享,他要求你在最短的时间内完成。

输入格式
第一行一个整数n。

下面每行,一个数x。

如果x=0,表示这个节点非叶子节点,递归地向下读入其左孩子和右孩子的信息,如果x≠0,表示这个节点是叶子节点,权值为x。

输出格式
输出一个整数,表示最少有多少逆序对。
样例输入
3
0
0
3
1
2
样例输出
1
数据规模与约定
对于20%的数据,n <= 5000。

对于100%的数据,1 <= n <= 200000,0 <= a[i]<2^31。

#include<stdio.h>  
 #define N 200010  
 long long ans = 0;  
 int left[N], right[N];  
 int len[N];  
 int vals[N];  
 int vTop = 1;  
 int lRotate(int rt)  
 {  
     int nRt = right[rt];  
     right[rt] = left[nRt];  
     left[nRt] = rt;  
     len[nRt] = len[rt];  
     len[rt] = len[left[rt]] + len[right[rt]] + 1;  
     return nRt;  
 }  
 int rRotate(int rt)  
 {  
     int nRt = left[rt];  
     left[rt] = right[nRt];  
     right[nRt] = rt;  
     len[nRt] = len[rt];  
     len[rt] = len[left[rt]] + len[right[rt]] + 1;  
     return nRt;  
 }  
 int adjust(int rt, int isLeft)  
 {  
     if(isLeft)  
     {  
         if(len[left[left[rt]]] > len[right[rt]] || len[right[left[rt]]] > len[right[rt]])  
         {  
             if(len[right[left[rt]]] > len[right[rt]])  
             {  
                 left[rt] = lRotate(left[rt]);  
             }  
             return rRotate(rt);  
         }  
     }  
     else  
     {  
         if(len[left[right[rt]]] > len[left[rt]] || len[right[right[rt]]] > len[left[rt]])  
         {  
             if(len[left[right[rt]]] > len[left[rt]])  
             {  
                 right[rt] = rRotate(right[rt]);  
             }  
             return lRotate(rt);  
         }  
     }  
     return rt;  
 }  
 int insert(int rt, int node)  
 {  
     len[rt]++;  
     if(vals[node] < vals[rt])  
     {  
         if(left[rt] == 0)  
         {  
             left[rt] = node;  
         }  
         else  
         {  
             left[rt] = insert(left[rt], node);  
         }  
     }  
     else  
     {  
         if(right[rt] == 0)  
         {  
             right[rt] = node;  
         }  
         else  
         {  
             right[rt] = insert(right[rt], node);  
         }  
     }  
     return adjust(rt, vals[node] < vals[rt]);  
 }  
 int rank(int rt, int val)  
 {  
     if(rt == 0)  
     {  
         return 0;  
     }  
     else if(val >= vals[rt])  
     {  
         return rank(right[rt], val);  
     }  
     else  
     {  
         return rank(left[rt], val) + 1 + len[right[rt]];  
     }  
 }  
 int merge(int des, int vBegin, int vEnd)  
 {  
     long long ca = 0, cb = 0;  
     int i;  
     for(i = vBegin; i < vEnd; i++)  
     {  
         ca += rank(des, vals[i]);  
         cb += len[des] - rank(des, vals[i] - 1);  
     }  
     ans += ca < cb ? ca : cb;  
     for(i = vBegin; i < vEnd; i++)  
     {  
         left[i] = right[i] = 0;  
         len[i] = 1;  
         des = insert(des, i);  
     }  
     return des;  
 }  
 int buildTree()  
 {  
     int val;  
     scanf("%d", &val);  
     if(val != 0)  
     {  
         left[vTop] = right[vTop] = 0;  
         len[vTop] = 1;  
         vals[vTop] = val;  
         return vTop++;  
     }  
     int ls = vTop;  
     int rlt = buildTree();  
     int rs = vTop;  
     int rrt = buildTree();  
     int re = vTop;  
     if(rs - ls > re - rs)  
     {  
         return merge(rlt, rs, re);  
     }  
     else  
     {  
         return merge(rrt, ls, rs);  
     }  
 }  
 int main(void)  
 {  
     int n;  
     scanf("%d", &n);  
     buildTree();  
     printf("%I64d", ans);  
     return 0;  
 }  

问题描述
有n个格子,从左到右放成一排,编号为1-n。

共有m次操作,有3种操作类型:

1.修改一个格子的权值,

2.求连续一段格子权值和,

3.求连续一段格子的最大值。

对于每个2、3操作输出你所求出的结果。

输入格式
第一行2个整数n,m。

接下来一行n个整数表示n个格子的初始权值。

接下来m行,每行3个整数p,x,y,p表示操作类型,p=1时表示修改格子x的权值为y,p=2时表示求区间[x,y]内格子权值和,p=3时表示求区间[x,y]内格子最大的权值。

输出格式
有若干行,行数等于p=2或3的操作总数。

每行1个整数,对应了每个p=2或3操作的结果。

样例输入
4 3
1 2 3 4
2 1 3
1 4 3
3 1 4
样例输出
6
3
数据规模与约定
对于20%的数据n <= 100,m <= 200。

对于50%的数据n <= 5000,m <= 5000。

对于100%的数据1 <= n <= 100000,m <= 100000,0 <= 格子权值 <= 10000。

 #include <stdio.h>  
 #define N 100000  
 #define A 1000  
 #define B 100  
 int sum(int* a, int m, int n)  
 {  
     int i, s = 0;  
     for (i = m; i <= n; i++)  
         s += a[i];  
     return s;  
 }  
 int max(int* a, int m, int n)  
 {  
     int i, s = a[m];  
     for (i = m + 1; i <= n; i++)  
         if (s < a[i])  
             s = a[i];  
     return s;  
 }  
 int main()  
 {  
     int i, j, k, m, n;  
     int a[100000], b[100000][3], c[A][2] = {0};  
     scanf("%d%d", &n, &m);  
     for (i = 0; i < n; i++)  
         scanf("%d", &a[i]);  
     for (i = 0; i < m; i++)  
         for (j = 0; j < 3; j++)  
             scanf("%d", &b[i][j]);  
     for (i = 0; i < (n + B - 1) / B; i++)  
     {  
         c[i][0] = c[i][1] = a[i * B];  
         for (j = i * B + 1; j < i * B + B && j < n; j++)  
         {  
             c[i][0] += a[j];  
             if (c[i][1] < a[j])  
                 c[i][1] = a[j];  
         }  
     }  
     for (i = 0; i < m; i++)  
     {  
         if (b[i][0] == 1)  
         {  
             c[(b[i][1] - 1) / B][0] += b[i][2] - a[b[i][1] - 1];  
             k = (b[i][1] - 1) / B;  
             if (c[k][1] <= b[i][2])  
             {  
                 c[k][1] = b[i][2];  
             }  
             else if (a[b[i][1] - 1] == c[k][1])  
             {  
                 a[b[i][1] - 1] = b[i][2];  
                 c[k][1] = max(a, k * B, k * B + B > n ? n - 1 : k * B + B - 1);  
             }  
             a[b[i][1] - 1] = b[i][2];  
         }  
         else if (b[i][0] == 2)  
         {  
             int s = 0;  
             b[i][1]--, b[i][2]--;  
             int o = b[i][2] / B - b[i][1] / B;  
             if (o < 2)  
             {  
                 s = sum(a, b[i][1], b[i][2]);  
             }  
             else  
             {  
                 s = sum(a, b[i][1], (b[i][1] + B) / B * B - 1);  
                 s += sum(a, b[i][2] / B * B, b[i][2]);  
                 for (j = b[i][1] / B + 1; j < b[i][2] / B; j++)  
                     s += c[j][0];  
             }  
             printf("%d\n", s);  
         }  
         else if (b[i][0] == 3)  
         {  
             int s = 0, t;  
             b[i][1]--, b[i][2]--;  
             int o = b[i][2] / B - b[i][1] / B;  
             if (o < 2)  
             {  
                 s = max(a, b[i][1], b[i][2]);  
             }  
             else  
             {  
                 s = max(a, b[i][1], (b[i][1] + B) / B * B - 1);  
                 t = max(a, b[i][2] / B * B, b[i][2]);  
                 if (s < t) s = t;  
                 for (j = b[i][1] / B + 1; j < b[i][2] / B; j++)  
                     if (s < c[j][1])  
                         s = c[j][1];  
             }  
             printf("%d\n", s);  
         }  
     }  
     return 0;  
 }  

算法训练 摆动序列

问题描述
  如果一个序列满足下面的性质,我们就将它称为摆动序列:
  1. 序列中的所有数都是不大于k的正整数;
  2. 序列中至少有两个数。
  3. 序列中的数两两不相等;
  4. 如果第i – 1个数比第i – 2个数大,则第i个数比第i – 2个数小;如

果第i – 1个数比第i – 2个数小,则第i个数比第i – 2个数大。
  比如,当k = 3时,有下面几个这样的序列:
  1 2
  1 3
  2 1
  2 1 3
  2 3
  2 3 1
  3 1
  3 2
  一共有8种,给定k,请求出满足上面要求的序列的个数。
输入格式
  输入包含了一个整数k。(k<=20)
输出格式
  输出一个整数,表示满足要求的序列个数。
样例输入
3
样例输出
8

 #include<stdio.h>   
 int f[21][21][21];   
 //f[i][j][k] i表示数的长度,j表示倒数第2位的取值,k表示最后一位的取值   
 int main()    
 {    
     int n,i,j,k,p;    
     int sum=0;    
     scanf("%d",&n);   
     for(i=1;i<=n;i++)  
         for(j=1;j<=n;j++)  
             if(i!=j)  
                 f[2][i][j]=1;  
     for(i=3;i<=n;i++)//从长度为3开始   
     {   
         for(j=1;j<=n;j++)  
         {  
             for(k=1;k<=n;k++)   
             {  
                 for(p=1;p<=n;p++)   
                 {  
                     if(j>p&&k<p||j<p&&k>p)  
                         f[i][j][k]+=f[i-1][p]  
 [j];  
                 }  
             }  
         }    
     }      
     for(i=2;i<=n;i++)   
     for(j=1;j<=n;j++)    
     for(k=1;k<=n;k++)   
       sum+=f[i][j][k];         
     printf("%d",sum);        
     return 0;  
 }  

算法训练 集合运算

问题描述
  给出两个整数集合A、B,求出他们的交集、并集以及B在A中的余集。
输入格式
  第一行为一个整数n,表示集合A中的元素个数。
  第二行有n个互不相同的用空格隔开的整数,表示集合A中的元素。
  第三行为一个整数m,表示集合B中的元素个数。
  第四行有m个互不相同的用空格隔开的整数,表示集合B中的元素。
  集合中的所有元素均为int范围内的整数,n、m<=1000。
输出格式
  第一行按从小到大的顺序输出A、B交集中的所有元素。
  第二行按从小到大的顺序输出A、B并集中的所有元素。
  第三行按从小到大的顺序输出B在A中的余集中的所有元素。
样例输入
5
1 2 3 4 5
5
2 4 6 8 10
样例输出
2 4
1 2 3 4 5 6 8 10
1 3 5
样例输入
4
1 2 3 4
3
5 6 7
样例输出
1 2 3 4 5 6 7
1 2 3 4

 #include <stdio.h>  
 #define MAX_N 1001  
 int n,m;  
 int Partition(int x[],int low,int high)  
 {  
     int pivotkey;  
     pivotkey = x[low];  
     while(low < high)  
     {  
         while(low<high && x[high]>=pivotkey)  
             high--;  
         x[low] = x[high];  
         while(low<high && x[low]<=pivotkey)  
             low++;  
         x[high] = x[low];  
     }  
     x[low] = pivotkey;  
     return low;  
 }  
 void QSort(int x[],int low,int high)  
 {  
     int pivotloc;  
     if(low < high)  
     {  
         pivotloc = Partition(x,low,high);  
         QSort(x,low,pivotloc-1);  
         QSort(x,pivotloc+1,high);  
     }  
 }  
 void jiao(int x[],int y[],int xx,int yy)  
 {  
     int i,j;  
     i = 1;  
     j = 1;  
     while(i<=xx && j<=yy)  
     {  
         if(x[i] == y[j])  
         {  
             printf("%d ",x[i]);  
             i++;  
             j++;  
         }  
         else if(x[i] < y[j])  
             i++;  
         else  
             j++;  
     }  
     printf("\n");  
 }  
 int bing(int x[],int y[],int z[],int xx,int yy)  
 {  
     int i,j,k;  
     i = 1;  
     j = 1;   
     k = 1;  
     while(i<=xx && j<=yy)  
     {  
         if(x[i] < y[j])  
         {  
             z[k] = x[i];  
             i++;  
         }  
         else if(x[i] > y[j])  
         {  
             z[k] = y[j];  
             j++;  
         }  
         else  
         {  
             z[k] = x[i];  
             i++;  
             j++;  
         }  
         k++;  
     }  
     if(i > xx)  
         while(j <= yy)  
         {  
             z[k] = y[j];  
             k++;  
             j++;  
         }  
     else  
         while(i <= xx)  
         {  
             z[k] = x[i];  
             k++;  
             i++;  
         }  
     return k;  
 }  
 void yu(int x[],int y[],int xx,int yy)  
 {  
     int i,j;  
     i = 1;  
     j = 1;  
     while(i<=xx && j<=yy)  
     {  
         if(x[i] == y[j])  
         {  
             i++;  
             j++;  
         }  
         else if(x[i] < y[j])  
         {  
             printf("%d ",x[i]);  
             i++;  
         }  
         else  
             j++;  
     }  
     if(j > yy)  
         while(i <= xx)  
         {  
             printf("%d ",x[i]);  
             i++;  
         }  
     printf("\n");  
 }  
 int main()  
 {  
     int i,l;  
     int a[MAX_N],b[MAX_N];  
     int c[2014];  
     scanf("%d",&n);  
     for(i=1; i<=n; i++)  
         scanf("%d",&a[i]);  
     QSort(a,1,n);  
     scanf("%d",&m);  
     for(i=1; i<=m; i++)  
         scanf("%d",&b[i]);  
     QSort(b,1,m);  
     jiao(a,b,n,m);  
     l = bing(a,b,c,n,m);  
     for(i=1; i<l; i++)  
         printf("%d ",c[i]);  
     printf("\n");  
     yu(a,b,n,m);  
     return 0;  
 }  
 #include <stdio.h>  
 #define MaxSize 1000+5  
 void printArrary(int num[],int n)  
 {  
     int i;  
     for(i=0;i<n;i++)  
     {  
         printf("%d ",num[i]);  
     }  
     printf("\n");  
     return ;  
 }  
 void inputNumber(int num[],int n)  
 {  
     int i;  
     for(i=0;i<n;i++)  
     {  
         scanf("%d",&num[i]);  
     }  
     return ;  
 }  
 void BubbleSort(int num[],int n)  
 {  
     int i,j,temp;  
     for(i=0;i<n;i++)  
     {  
         for(j=n-1;j>i;j--)  
         {  
             if(num[j]<num[j-1])  
             {  
                 temp=num[j];  
                 num[j]=num[j-1];  
                 num[j-1]=temp;  
             }  
         }  
     }  
     return ;  
 }  
 void getIntersectionElements(int num1[],int num2[],int n,int m,int   
 Intersection[],int *points)  
 {  
     int i,j;  
     for(i=0;i<n;i++)  
     {  
         for(j=0;j<m;j++)  
         {  
             if(num1[i]==num2[j])  
             {  
                 printf("%d ",num1[i]);  
                 //存入交集数组  
                 Intersection[*points]=num1[i];  
                 (*points)++;   
                 break;  
             }  
         }  
     }  
     if(*points)  
     printf("\n");  
     return ;  
 }  
 void getAll(int num1[],int num2[],int n,int m,int Intersection[],int   
 *points)  
 {  
     int num[2*MaxSize],sum;  
     int i,j,k=0;  
     for(i=0;i<n;i++)  
     {  
         num[i]=num1[i];  
     }  
     for(j=i;j<i+m;j++)  
     {  
         num[j]=num2[k++];  
     }  
     if(*points==0)  
     {  
         BubbleSort(num,m+n);  
         printArrary(num,m+n);  
     }  
     else  
     {  
         BubbleSort(num,m+n);  
         for(i=0;i<m+n;i++)  
         {  
             if(i)  
             {  
                 if(num[i]!=num[i-1])  
                 printf("%d ",num[i]);  
             }  
             else  
             {  
                 printf("%d ",num[0]);  
             }  
         }  
         printf("\n");  
     }  
     return ;  
 }  
 void getTheOther(int num[],int n,int Intersection[],int *points)  
 {  
     int i,j,flag=1;  
     if(*points==0)  
     {  
         printArrary(num,n);  
     }  
     else  
     {  
         for(i=0;i<n;i++)  
         {  
             flag=1;  
             for(j=0;j<*points;j++)  
             {  
                 if(num[i]==Intersection[j])  
                 {  
                     flag=0;  
                     break;  
                 }     
             }  
             if(flag)  
             {  
                 printf("%d ",num[i]);  
             }  
         }  
         printf("\n");  
     }  
     return ;  
 }  
 main()  
 {  
     int m,n,A[MaxSize],B[MaxSize],Intersection[MaxSize];  
     int i,points=0;  
     //数据输入   
     scanf("%d",&n);  
     inputNumber(A,n);  
     scanf("%d",&m);  
     inputNumber(B,m);  
     //数据处理  
     BubbleSort(A,n);  
     BubbleSort(B,m);   
     //输出交集   
     getIntersectionElements(A,B,n,m,Intersection,&points);  
     //输出并集   
     getAll(A,B,n,m,Intersection,&points);  
     //输出B于A的补集  
     getTheOther(A,n,Intersection,&points);   
     //结果输出   
     //printArrary(Intersection,points);  
     return 0;  
 }  

算法训练 瓷砖铺放

问题描述
  有一长度为N(1<=N<=10)的地板,给定两种不同瓷砖:一种长度为1,另一

种长度为2,数目不限。要将这个长度为N的地板铺满,一共有多少种不同的铺法


  例如,长度为4的地面一共有如下5种铺法:
  4=1+1+1+1
  4=2+1+1
  4=1+2+1
  4=1+1+2
  4=2+2
  编程用递归的方法求解上述问题。
输入格式
  只有一个数N,代表地板的长度
输出格式
  输出一个数,代表所有不同的瓷砖铺放方法的总数
样例输入
4
样例输出
5

 #include <stdio.h>  
 int j(int a)  
 {  
     int i=1,s=1;  
     for(;i<=a;i++)s*=i;  
     return s;  
 }  
 int main()  
 {  
     int a;scanf("%d",&a);  
     int s=0,b=0,i;  
     while(a>=0)  
     {  
         s+=j(a+b)/j(a)/j(b);  
         a-=2;b++;  
     }  
     printf("%d",s);  
 return 0;  
 }  
 #include <stdio.h>  
 void funtion(int lenth,int *count)  
 {  
     //出口设计   
     if(lenth==0||lenth==1)  
     {  
         (*count)++;  
         return ;  
     }  
     //递归情况一   
     funtion(lenth-1,count);  
     //递归情况二   
     funtion(lenth-2,count);  
 }  
 main()  
 {  
     int N,count=0;  
     scanf("%d",&N);  
     funtion(N,&count);  
     printf("%d\n",count);  
     return 0;  
 }  

算法训练 幂方分解

问题描述
  任何一个正整数都可以用2的幂次方表示。例如:
  137=2的7次方+2的3次方+2的0次方
  同时约定方次用括号来表示,即ab 可表示为a(b)。
  由此可知,137可表示为:
  2(7)+2(3)+2(0)
  进一步:7= 2的2次方+2+2的0次方 (21用2表示)
  3=2+2的0次方
  所以最后137可表示为:
  2(2(2)+2+2(0))+2(2+2(0))+2(0)
  又如:
  1315=2的10次方 +2的8次方 +2的5次方 +2+1
  所以1315最后可表示为:
  2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2(0))+2+2(0


输入格式
  输入包含一个正整数N(N<=20000),为要求分解的整数。
输出格式
  程序输出包含一行字符串,为符合约定的n的0,2表示(在表示中不能有空

格)

 #include<stdio.h>  
 void f(int a)  
 {  
     int i=0,j,b[32],w,k;  
     if(a==0)printf("0");  
     else if(a==2)printf("2");  
     else if(a==1)printf("2(0)");  
     else   
     {  
         while(a){b[i]=a%2;a=a/2;i++;}w=i;  
     k=0;j=0;for(i=w-1;i>=0;i--)if(b[i])k++;  
     for(i=w-1;i>=0;i--)  
         if(b[i])  
     {j++;  
     if(i==1)printf("2");  
     else {printf("2(");f(i);printf(")");}  
     if(j!=k)printf("+");}  
     }  
 }  
 int main()  
 {  
     int a;scanf("%d",&a);  
     f(a);  
     return 0;  
 }  

算法训练 拦截导弹

问题描述
  某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统。但是这种导弹拦

截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发

炮弹都不能高于前一发的高度。某天,雷达捕捉到敌国的导弹来袭。由于该系统

还在试用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹。

  输入导弹依次飞来的高度(雷达给出的高度数据是不大于30000的正整数)

,计算这套系统最多能拦截多少导弹,如果要拦截所有导弹最少要配备多少套这

种导弹拦截系统。
输入格式
  一行,为导弹依次飞来的高度
输出格式
  两行,分别是最多能拦截的导弹数与要拦截所有导弹最少要配备的系统数
样例输入
389 207 155 300 299 170 158 65
样例输出
6
2

 #include <stdio.h>  
 #define MAX_N 10000  
 int dp[MAX_N]={0};  
 int i=0;  
 int dao[MAX_N];  
 int max(int a,int b)  
 {  
     return a>b?a:b;  
 }  
 void solve1()  
 {  
     int k,j;  
     int res = 0;  
     int n = i;  
     for(j=0; j<n; j++)  
     {  
         dp[j] = 1;  
         for(k=0; k<j; k++)  
             if(dao[k] > dao[j])  
                 dp[j] = max(dp[j],dp[k]+1);  
         res = max(res , dp[j]);  
     }  
     printf("%d\n",res);  
 }  
 void solve2()  
 {  
     int k,j;  
     int res = 0;  
     int n = i;  
     for(j=0; j<n; j++)  
     {  
         dp[j] = 1;  
         for(k=0; k<j; k++)  
             if(dao[k] < dao[j])  
                 dp[j] = max(dp[j],dp[k]+1);  
         res = max(res , dp[j]);  
     }  
     printf("%d\n",res);  
 }  
 int main()  
 {  
     char q;  
     int s=0;  
     while(q=getchar())  
     {  
         if(q>='0' && q<='9')  
             s = s*10+q-'0';  
         else if(q == ' ')  
         {  
             dao[i] = s;  
             i++;  
             s = 0;  
         }  
         else  
             break;  
     }  
     dao[i] = s;  
     i++;  
     solve1();  
     solve2();  
     return 0;  
 }  

算法训练 回文数

问题描述
  若一个数(首位不为零)从左向右读与从右向左读都一样,我们就将其称之

为回文数。
  例如:给定一个10进制数56,将56加65(即把56从右向左读),得到121是

一个回文数。

  又如:对于10进制数87:
  STEP1:87+78 = 165 STEP2:165+561 = 726
  STEP3:726+627 = 1353 STEP4:1353+3531 = 4884

  在这里的一步是指进行了一次N进制的加法,上例最少用了4步得到回文数

4884。

  写一个程序,给定一个N(2<=N<=10或N=16)进制数M(其中16进制数字为0

-9与A-F),求最少经过几步可以得到回文数。
  如果在30步以内(包含30步)不可能得到回文数,则输出“Impossible!”
输入格式
  两行,N与M
输出格式
  如果能在30步以内得到回文数,输出“STEP=xx”(不含引号),其中xx是

步数;否则输出一行”Impossible!”(不含引号)
样例输入
9
87
样例输出
STEP=6

 #include<stdio.h>  
  #include<math.h>  
  #include <string.h>  
  #include <stdlib.h>  
  int p;  
  char s[1000];  
  int c[1000];  
  int reverse(int a[],int n)  判断a是否是回文   
  {  
      int i,j;  
      i=0;  
      j=n-1;  
      while(i<j&&a[i]==a[j])  
      {  
         i++;  
         j--;  
      }  
      return i>=j;  
  }  
  int aplus(int a[],int n,int m)    计算a=a+a   
  {  
       int *b,i,j,kc;  
       b=(int *)malloc(sizeof(int)*1001);  
       for(i=0;i<n;i++)  
          b[n-1-i]=a[i];  
       kc=0;  
       for(i=0;i<n;i++)  
       {  
          a[i]=a[i]+b[i]+kc;  
          kc=a[i]/m;  
          a[i]=a[i]%m;  
       }  
       if(kc>0)  
         a[n++]=kc;  
       free(b);  
       return n;  
  }  
  int  stod(char s[],int a[])  
  {  
       int i;  
       for(i=0;s[i]!='\0';i++)  
          if(s[i]>='A'&&s[i]<='F')  
             a[i]=10+s[i]-'A';  
          else  
             a[i]=s[i]-'0';  
       return i;  
  }   
  int main()  
  {  
      int n,i;  
      scanf("%d",&p);  
      scanf("%s",s);  
      n=stod(s,c);  
      for(i=0;i<30;i++)  
      {  
         n=aplus(c,n,p);  
         if(reverse(c,n)==1)  
           {  
              printf("STEP=%d\n",i+1);  
              break;  
           }  
      }  
      if(i>=30)  
        printf("Impossible!\n");  
 return 0;  
  }  

算法训练 旅行家的预算

问题描述
  一个旅行家想驾驶汽车以最少的费用从一个城市到另一个城市(假设出发时油箱是空的)。给定两个城市之间的距离D1、汽车油箱的容量C(以升为单位)、每升汽油能行驶的距离D2、出发点每升汽油价格P和沿途油站数N(N可以为零),油站i离出发点的距离Di、每升汽油价格Pi(i=1,2,……N)。计算结果四舍五入至小数点后两位。如果无法到达目的地,则输出“No Solution”。
输入格式
  第一行为4个实数D1、C、D2、P与一个非负整数N;
  接下来N行,每行两个实数Di、Pi。
输出格式
  如果可以到达目的地,输出一个实数(四舍五入至小数点后两位),表示最小费用;否则输出“No Solution”(不含引号)。
样例输入
275.6 11.9 27.4 2.8 2
102.0 2.9
220.0 2.2
样例输出
26.95

 #include <stdio.h>  
 #define MAX_N 100  
 float D1,C,D2,P;  
 float A[MAX_N],B[MAX_N];  
 int N;  
 void solve()  
 {  
     int i;  
     float res = 0;  
     float pos,tank;  
     pos = B[0];  
     tank = C;  
     res += pos*tank;  
     float we=0;  
     for(i=1; i<N; i++)  
     {  
         tank -= (A[i] - A[i-1]-we)/D2;  
         if(B[i] < pos)  
         {  
             we = 0;  
             res -= tank*pos;  
             tank = C;  
             pos = B[i];  
             res += tank*pos;  
         }  
         else  
         {  
             if(tank < (A[i+1]-A[i])/D2)  
             {  
                  we=0;  
                 we = tank*D2;  
                 tank = C;  
                 pos = B[i];  
                 res += tank*pos;  
             }  
             if(tank < 0)  
             {  
                 puts("No Solution\n");  
                 return ;  
             }  
         }  
     }  
     tank -= (D1-A[i-1]-we)/D2;  
     if(tank < 0)  
         {  
             puts("No Solution\n");  
             return ;  
         }  
     res -= tank*pos;  
     printf("%.2f\n",res);  
 }  
 int main()  
 {  
     int i;  
     scanf("%f%f%f%f%d",&D1,&C,&D2,&P,&N);  
     A[0] = 0;  
     B[0] = P;  
     N++;  
     A[N] = D1;  
     for(i=1; i<N; i++)  
         scanf("%f%f",&A[i],&B[i]);  
     if(D1 != 0)  
         solve();  
     else  
         puts("No Solution\n");  
     return 0;  
 }  

算法训练 进制转换

问题描述

cf为次方
  我们可以用这样的方式来表示一个十进制数: 将每个阿拉伯数字乘以一个以该数字所处位置的(值减1)为指数,以10为底数的幂之和的形式。例如:123可表示为 1*102+2*101+3*100这样的形式。
  与之相似的,对二进制数来说,也可表示成每个二进制数码乘以一个以该数字所处位置的(值-1)为指数,以2为底数的幂之和的形式。一般说来,任何一个正整数R或一个负整数-R都可以被选来作为一个数制系统的基数。如果是以R或-R为基数,则需要用到的数码为 0,1,....R-1。例如,当R=7时,所需用到的数码是0,1,2,3,4,5和6,这与其是R或-R无关。如果作为基数的数绝对值超过10,则为了表示这些数码,通常使用英文字母来表示那些大于9的数码。例如对16进制数来说,用A表示10,用B表示11,用C表示12,用D表示13,用E表示14,用F表示15。
  在负进制数中是用-R 作为基数,例如-15(十进制)相当于110001(-2进制),并且它可以被表示为2的幂级数的和数:
  110001=1*(-2)5cf+1*(-2)4cf+0*(-2)3cf+0*(-2)2cf+
  0*(-2)1cf +1*(-2)0cf
   设计一个程序,读入一个十进制数和一个负进制数的基数, 并将此十进制数转换为此负进制下的数: -R∈{-2,-3,-4,...,-20}

输入格式
  一行两个数,第一个是十进制数N(-32768<=N<=32767), 第二个是负进制数的基数-R。

输出格式
  输出所求负进制数及其基数,若此基数超过10,则参照16进制的方式处理。(格式参照样例)

  样例输入1
  30000 -2
样例输出
30000=11011010101110000(base-2)
样例输入
-20000 -2
样例输出
-20000=1111011000100000(base-2)
样例输入
28800 -16
样例输出
28800=19180(base-16)
样例输入
-25000 -16
样例输出
-25000=7FB8(base-16)

 #include <stdio.h>  
 const char nc[20]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','I','J'};  
 char str[20];  
 int main()  
 {  
     int m, n, k, t, s;  
     int i=0;  
     scanf("%d%d",&m,&n);  
     s = m;  
     while(m != 0)  
     {  
         k = m % n;  
         t = m / n;  
         if(k < 0)  
         {  
             k -= n;  
             t++;  
         }  
         m = t;  
         str[i++]=nc[k];  
     }  
     printf("%d=",s);  
     for(i = i- 1; i >= 0; i--)  
         printf("%c",str[i]);  
     printf("(base%d)\n",n);  
     return 0;  
 }  

算法训练 乘积最大

问题描述

  今年是国际数学联盟确定的“2000——世界数学年”,又恰逢我国著名数学家华罗庚先生诞辰90周年。在华罗庚先生的家乡江苏金坛,组织了一场别开生面的数学智力竞赛的活动,你的一个好朋友XZ也有幸得以参加。活动中,主持人给所有参加活动的选手出了这样一道题目:

  设有一个长度为N的数字串,要求选手使用K个乘号将它分成K+1个部分,找出一种分法,使得这K+1个部分的乘积能够为最大。

  同时,为了帮助选手能够正确理解题意,主持人还举了如下的一个例子:

  有一个数字串:312, 当N=3,K=1时会有以下两种分法:

  312=36   312=62

  这时,符合题目要求的结果是:31*2=62

  现在,请你帮助你的好朋友XZ设计一个程序,求得正确的答案。

输入格式

  程序的输入共有两行:
  第一行共有2个自然数N,K(6≤N≤40,1≤K≤6)
  第二行是一个长度为N的数字串。

输出格式

  输出所求得的最大乘积(一个自然数)。

  样例输入

  4 2
  1231
样例输出
62

 #include <stdio.h>  
 #define maxN 41  
 #define maxK 7  
 #define InfiniteMin -999999999  
 int main()  
 {  
     int N,K;  
     int i,j,k,m;  
     int A[maxN][maxK];   A[i][j]表示前i个数有j个乘号能达到的最大乘积   
     int s[maxN];  
     char num[maxN];   
     int temp,max;  
     scanf("%d%d%s",&N,&K,num);  
     for(i=0;i<N;i++)  
         s[i+1]=num[i]-'0';  
     for(i=1;i<=N;i++)  
     {  
         temp=0;  
         for(j=1;j<=i;j++)  
             temp=temp*10+s[j];  
         A[i][0]=temp;  
     }  
     for(j=1;j<=K;j++)  
     {  
         for(i=j+1;i<=N;i++)  
         {  
             max=InfiniteMin;  
             for(k=i;k-1>j-1;k--)  
             {  
                 temp=0;  
                 for(m=k;m<=i;m++)  
                     temp=temp*10+s[m];   
                 temp*=A[k-1][j-1];  
                 max=max>temp?max:temp;  
             }  
             A[i][j]=max;  
         }  
     }  
     printf("%d",A[N][K]);  
     return 0;  
 }  

算法训练 方格取数

问题描述
  设有NN的方格图(N<=10),我们将其中的某些方格中填入正整数,而其他的方格中则放入数字0。   某人从图的左上角的A 点(1,1)出发,可以向下行走,也可以向右走,直到到达右下角的B点(N,N)。在走过的路上,他可以取走方格中的数(取走后的方格中将变为数字0)。   此人从A点到B 点共走两次,试找出2条这样的路径,使得取得的数之和为最大。 输入格式   输入的第一行为一个整数N(表示NN的方格图),接下来的每行有三个整数,前两个表示位置,第三个数为该位置上所放的数。一行单独的0表示输入结束。
输出格式
  只需输出一个整数,表示2条路径上取得的最大的和。
样例输入
  8
  2 3 13
  2 6 6
  3 5 7
  4 4 14
  5 2 21
  5 6 4
  6 3 15
  7 2 14
  0 0 0
样例输出
  67

 #include <stdio.h>  
 #define max(a,b) a>b?a:b  
 #define min(a,b) a<b?a:b  
 int main()  
 {  
     int map[11][11]={0},f[11][11]={0};  
     int i,j,k,N,t;  
     scanf("%d",&N);  
     while (scanf("%d%d%d",&i,&j,&k)&&(i||j||k)) map[i][j]=k;  
     for (i=2;i<=2*N;i++)  
         for (t=min(i,N),j=t;j>0;j--)  
             for (k=t;k>0;k--)  
             {  
                 f[j][k]=max(f[j][k],f[j-1][k-1]);  
                 f[j][k]=max(f[j][k],f[j][k-1]);  
                 f[j][k]=max(f[j][k],f[j-1][k]);  
                 if (j==k) f[j][k]+=map[j][i-j];  
                 else f[j][k]+=map[j][i-j]+map[k][i-k];  
             }  
     printf("%d",f[N][N]);  
     return 0;  
 }  

算法训练 求先序排列

问题描述
  给出一棵二叉树的中序与后序排列。求出它的先序排列。(约定树结点用不同的大写字母表示,长度<=8)。
输入格式
  两行,每行一个字符串,分别表示中序和后序排列
输出格式
  一个字符串,表示所求先序排列

  样例输入
  BADC
  BDCA
样例输出
ABCD

 #include"stdio.h"  
 #include"string.h"  
 void dg(char z[],char h[])  
 {  
     if(strlen(h)==0)  
         return;  
     printf("%c",h[strlen(h)-1]);  
     if(strlen(h)==1)  
         return;  
     if(strlen(h)==2)  
     {  
         printf("%c",h[0]);  
         return;  
    }  
     char a[9],b[9];  
     int i,j;  
    for(i=0;z[i]!=h[strlen(h)-1];i++)  
        a[i]=z[i],b[i]=h[i];  
     a[i]='\0';  
     b[i++]='\0';  
     dg(a,b);  
     for(j=0;i<strlen(h);i++,j++)  
         a[j]=z[i],b[j]=h[i-1];  
     a[j]='\0';  
     b[j]='\0';  
     dg(a,b);  
 }  
 int main()  
 {  
     char h[9],z[9];  
     scanf("%s",z);  
    scanf("%s",h);  
    dg(z,h);  
     return 0;  
 }  
阅读更多
换一批

没有更多推荐了,返回首页