正在复习，帮自己整理一下
 一、已知五个学生成绩，找出成绩最优者，最差者并输出，学生信息包括学号、姓名、成绩
 
#include<stdio.h>
#define N 5
struct student
{
int ID；
char name[20];
float score;
};
int main()
{
struct student[5]={{123,"wang",99.8},{456,"ming",97.9},{789,"fang",100},{245,"xuan",77},{869,"qing",87};
int low,high,maxscore,minscore;
maxscore=minscore=student[0].score;
low=high=0;
for(int i=0;i<N;i++){
    if(student[i].score>maxscore)
    {
        high=i;
        maxscore=student[i].score;
     }
     else if(student[i].score<minscore)
     {
        low=i;
        minscore=student[i].score;
     }
 }
printf("%smax的成绩是%.1f",student[high].name,student[high].score);
printf("%smin的成绩是%.1f",student[low].name,student[low].score);
return 0;
} 
 
二、运用结构体指针变量，录入学生信息，计算学生成绩平均值，以及输出学生平均成绩在80~90的信息
 
#include<stdio.h>
#define N 3
struct student{
int ID;
char name[20];
int score[N];
float aver;
};
void input(struct student *p);
void average(struct student *p);
void qujian(struct student *p);
int main()
{
struct student stu[N];
printf("Please input.\n");
input(stu);
printf("There are averages.\n");
average(stu);
printf("There are scores.\n");
qujian(stu);
return 0;
}
void input(struct student *p)
{
for(int i=0;i<N;i++)
{
   scanf("%d%s%d%d%d",&p->ID,p->name,&p->score[0],&p->score[1],&p->score[2]);
   p++;
}
}
void average(struct student *p)
{
   for(int i=0;i<N;i++)
   {
       p->aver=(p->score[0]+p->score[1]+p->score[2])/3;
       printf("\n%5.2f",p->aver);
       p++;
   }
}
void qujian(struct student *p)
{
for(int i=0;i<N;i++)
{
   if(p->aver>=80&&p->aver=<90)
   {
       printf("\n%s%5d%5d%5d%5.2f",p->name,p->score[0],p->score[1],p->score[2],p->aver);
   }
   p++;
}
}

 
使用Excel对学生成绩进行分数统计（区间判别）
 
数据图示
对应等级判断（LOOKUP）
分数判断（VLOOKUP）
个数统计（SUMPRODUCT）
 

 
前不久跟着本系的老师进行了基于全校学生体测数据的学生大学四年体质的一个分析，我负责数据统计这方面，由于最后的分析报告要运用到图表进行可视化，于是就最后选用了Excel。
 
数据图示
 
数据已经进行脱敏操作，展示如下
 
其中男生（性别为1）测1000和引体，女生测800和仰卧
 
 
我负责的就是统计出各学院间各项测试的优良及格不及格的人数，还有每个人对应的最终分数。
 
对应等级判断（LOOKUP）
 
首先我要做的是判断每个成绩所对应的等级，由于男女标准不同，所以我就用了 IF 和 LOOKUP 这两个函数
 
以肺活量为例
 
 =IF(D2=1,LOOKUP(E2,{0,3100,4300,4800},{“不及格”,“及格”,“良”,“优”}),LOOKUP(E2,{0,2000,3000,3300},{“不及格”,“及格”,“良”,“优”}))
 
=IF(D2=1,LOOKUP(E2,{0,3100,4300,4800},{"不及格","及格","良","优"}),LOOKUP(E2,{0,2000,3000,3300},{"不及格","及格","良","优"}))
 
LOOKUP的作用就是判断一列的数据（E2）是否处于第一个{}里，如果是则返回第二个{}里所对应的字符，否则会报错， 第一个{}就相当于是一个区间，不过必须要从小到大排列， 第二个{}里就是所返回的字符，当然其个数要与前一个{}的区间段的个数对应；当然这里也可以用 VLOOKUP，不过对于这种区间少的其操作程度与 LOOKUP差不多
 
效果图
 
 
分数判断（VLOOKUP）
 
评分标准图示
 
 
先将对应年级的标准复制到原数据表的后面，由于VLOOKUP函数的需要，标准表需要从上到下由小到大排列，为了方便我将对应分数都复制到了每项成绩之后
 
 
=IF(G2=1,VLOOKUP(J2,$AI $ 2:$AJ $ 22,2),VLOOKUP(J2,$AI $ 25:$AJ $45,2))
 
=IF(G2=1,VLOOKUP(J2,$AI$2:$AJ$22,2),VLOOKUP(J2,$AI$25:$AJ$45,2))
 
 
以第一个VLOOKUP(J2,$AI $ 2:$AJ$22,2)为例，J2是要进行判断的单元格， $AI $ 2:$AJ$22是一个数组区域，是在其中搜索数据的信息表，其区域大小是AI2：AJ22， $代表引用的是绝对地址，即选中的区域不随J列单元格的增加而移动（固定区域），最后的2代表返回的数据是数组区域的第2列（AJ列）中的数据
 
个数统计（SUMPRODUCT）
 
 
=SUMPRODUCT(($B $ 1:$B $ 20000=$ Z2)*($Q $ 1:$Q$20000=AA$1))
 
=SUMPRODUCT(($B$1:$B$20000=$Z2)*($Q$1:$Q$20000=AA$1))
 
SUMPRODUCT 的作用是返回相应的数组或区域的乘积的和，在这里返回的是满足每一个（）里的条件的数值的个数；这里第一个（）统计的是B列数据的值与Z2单元格相同的个数，第二个（）统计的是Q列数据的值与AA1单元格相同的个数，结果相交即为所求个数

 
package t2;
 
import java.util.Scanner;
 
public class test {
 
public static void main(String[] args) {
 
for(;;)
 
{
 
Scanner input = new Scanner(System.in);
 
System.out.println("请输入学生的分数：");
 
double score = input.nextDouble();
 
int level1,level2;
 
if(score>=90.0 && score<=100.0){ level1 = 1;}
 
else if(score>=80.0){ level1 = 2;}
 
else if(score>=70.0){ level1 = 3;}
 
else if(score>=60.0){ level1 = 4;}
 
else{ level1 = 5;}
 
if(score>=85.0&&score<=100.0){level2 = 1;}
 
else if(score>=70.0){level2 = 2;}
 
else if(score>=60.0){level2 = 3;}
 
else{level2 = 4;}
 
switch(level1)
 
{
 
case 1:
 
System.out.print("该生的成绩等级是：  优");
 
break;
 
case 2:
 
System.out.print("该生的成绩等级是：  良");
 
break;
 
case 3:
 
System.out.print("该生的成绩等级是：  中");
 
break;
 
case 4:
 
System.out.print("该生的成绩等级是： 及格");
 
break;
 
case 5:
 
System.out.print("该生的成绩等级是： 不及格");
 
break;
 
}
 
switch(level2)
 
{
 
case 1:
 
System.out.println("   A ");
 
break;
 
case 2:
 
System.out.println("   B ");
 
break;
 
case 3:
 
System.out.println("   C ");
 
break;
 
case 4:
 
System.out.println("   D ");
 
break;
 
}
 
}
 
}
 
}
 
结果：
 

 
解析看不懂？求助智能家教解答查看解答

 
区间dp
 
这篇博客持续更新中......
对区间dp的简单介绍：
P1880 [NOI1995]石子合并：
分析：
优化：
完整代码如下：
   
P1063 能量项链
分析：
代码如下：
   
P1040 加分二叉树
分析：
代码如下：
  
 

 
这篇博客持续更新中…
 
对区间dp的简单介绍：
 
  区间dp也属于线性dp中的一种，它以“区间长度”作为dp的“阶段”，使用两个坐标（区间的左、右端点）描述每个维度。在区间dp中，一个状态由若干个比它更小且包含于它的区间所代表的的状态转移而来，因此区间dp的决策往往就是划分区间的方法。区间dp的初态一般就又长度为1的“元区间”构成。
 
P1880 [NOI1995]石子合并：
 
  洛谷：P1880 石子合并
 题目描述
   在一个圆形操场的四周摆放 N 堆石子,现要将石子有次序地合并成一堆.规定每次只能选相邻的2堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。
   试设计出一个算法,计算出将 N 堆石子合并成 1 堆的最小得分和最大得分。
 输入格式
   数据的第 1 行是正整数 N，表示有 N 堆石子。
   第 2 行有 N 个整数，第 i 个整数 ai 表示第 i 堆石子的个数。
 输出格式
   输出共 2 行，第 1 行是最小得分，第 2 行是最大得分。
 
分析：
 
  若最初的第 l 堆石子和第 r 堆石子被合并成一堆，则说明 l ~ r 之间的每堆石子也已经被合并，这样 l 和 r 才有可能相邻。因此，在任意时刻，任意一堆石子均可以用一个闭区间［l, r]来描述，表示这堆石子是由最初的第 l ~ r 堆石子合并而成的，其重量为${\sum }_{j=l}^{r}A[i]$另外，一定存在一个整数k (l ≤ k < r),在这堆石子形成之前，先有第1 ~ k 堆石子（闭区间［l,k]) 被合并成一堆，还要有第k + 1~r 堆石子（闭区间［k + 1,r])被合并成一堆，然后这两堆石子才合并成［L, r]。
   对应到动态规划中，就意味着两个长度较小的区间上的信息向一个更长的区间发生了转移，划分点 k 就是转移的决策。自然地，应该把区间长度 len 作为dp的阶段。不过，区间长度可以由左端点和右端点表示出，即len = r - l + 1。本着动态规划“选择最小的能覆盖状态空间的维度集合”的思想，可以只用左、右端点表示dp的状态。
   接下来我们先不考虑每堆石子的环形结构，先分析每堆石子是排成一排时的情况：
   基于两个长度较小的区间上的信息向一个更长的区间发生了转移的思想，首先，我们要不断从较短的区间求到较长的区间，所以从 2 ~ n 枚举区间的长度，当我们确定了区间长度的时候，再枚举左端点 l ，由于区间长度是确定的，所以右端点 r 也被确定了。接着，因为我们已经确定了某个特定的区间，接下来就是枚举区间的分割点 k ，所以每个区间（l ~ r）的得分是左区间（l ~ k）的得分 + 右区间（k + 1 ~ r）的得分 + 两个区间的石子合并时候的得分。
   先讨论合并所有石子之后的最小得分，设F[l, r]表示把最初的第 l 堆到第 r 堆合并成一堆，状态方程式：
 
     
      
       
        
         F
        
        
         [
        
        
         l
        
        
         ,
        
        
         r
        
        
         ]
        
        
         =
        
        
         
          
           min
          
          
           ⁡
          
         
         
          
           l
          
          
           ≤
          
          
           k
          
          
           <
          
          
           r
          
         
        
        
         {
        
        
         F
        
        
         [
        
        
         l
        
        
         ,
        
        
         k
        
        
         ]
        
        
         +
        
        
         F
        
        
         [
        
        
         k
        
        
         +
        
        
         1
        
        
         ,
        
        
         r
        
        
         ]
        
        
         +
        
        
         
          ∑
         
         
          
           i
          
          
           =
          
          
           l
          
         
         
          r
         
        
        
         A
        
        
         [
        
        
         i
        
        
         ]
        
       
       
        F[l, r] = \min_{l{\leq}k<r} \{F[l, k] +F[k + 1, r] + \sum_{i = l}^{r}A[i]
       
      
     F[l,r]=l≤k<rmin​{F[l,k]+F[k+1,r]+i=l∑r​A[i]
   初值：$\forall$ l $\in$ [1, n], f[l, l] = A[i], 其余为正无穷。
   目标：f[1, n]
   在解决动态规划问题、求状态转移方程时，务必分清阶段、状态与决策，三者应该按照从外到内的顺序依次循环，对于${\sum }_{i=l}^{r}A[i]$，可使用前缀和计算。
   利用三层循环实现这一过程：
 
for(len = 2; len <= n; len++){
        for(i = 1; i <= n - len + 1; i++){
            l = i;
            r = i + len - 1;
            f[l][r] = 1e8;
            for(k = l; k < r; k++) f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + a[r] - a[l - 1]);  //a数组是前缀和
        }
}
 
优化：
 
  上面的分析过程是基于每堆石子之间是排列成链状结构的，而题目是环形石子合并，即我们上面讨论的链式石子合并中，首堆石子和末堆石子是可以两两合并的，现在我们要解决的是：如何把环转换成区间。其实，我们在合并两堆石子的过程中，可以看做是在两个点之间作一条边连起来，每堆石子之间如果已经有边相连，就可以看做它们已经合并成同一堆石子。
   已知我们需要合并n堆石子，因为n堆石子可以看做是以n个点，且呈现环状分布，每合并一次，就在两点之间连上一条线，当所有石子最终合并成一大堆，就可以看做所有点连成了一条链，此时我们用了n - 1条线把n个点连起来。所以，我们能合成n条不同的链，已知上述已分析的链式结构的时间复杂度为O(N3)，现在枚举 n 条不同的链，时间复杂度变成了O(N4)，由于时间复杂度过高，会造成超时，所以枚举 n 条链的做法不可取。其实，对于环形结构的问题，有个常见的优化方式，把环展开成链状，并把链的长度扩展一倍，即有两条相同的链首尾相连形成长度为2 * n的链，已知用 n - 1 条线合并 n 个点会产生一个缺口，把那个缺口左右两边的两个点就是这条链的左端点和右端点。
   所以，问题就转换成在 2 * n 的区间中，枚举每个长度为n的区间，对他们进行各种操作得到最值(保存在f[l][r]数组中，每段区间的 l 和 r 都不同)，最后用一个for循环得到 n 个区间的最值。
 
完整代码如下：
 
#include <bits/stdc++.h>
using namespace std;
int a[205], f1[405][405], f2[405][405], s[405]; //因为将环拆为2 * n的链，所以数组的范围都要对应地乘2
int main(){
    int i, k, n, t, len, l, r;
    scanf("%d", &n);
    for(i = 1; i <= n; i++){
        scanf("%d", &a[i]);
        s[i] = a[i] + s[i - 1]; //a数组是原数组，s数组是前缀和数组
    }
    for(i = n + 1; i <= 2 * n; i++) s[i] = a[i - n] + s[i - 1]; //更新链后半段的前缀和数组
    for(len = 2; len <= n; len++){	//枚举区间长度(2 ~ 2)
        for(i = 1; i <= 2 * n - len + 1; i++){	 
            l = i;	//l为区间的左端点
            r = i + len - 1;	//r为区间右端点	 
            f1[l][r] = 1e8;		//f1数组是求最小得分
            f2[l][r] = 0;		//f2数组是求最大得分
            for(k = l; k < r; k++){	//从l到r枚举分界点
				f1[l][r] = min(f1[l][r], f1[l][k] + f1[k + 1][r] + s[r] - s[l - 1]);
				f2[l][r] = max(f2[l][r], f2[l][k] + f2[k + 1][r] + s[r] - s[l - 1]); 
			}	
        }
    }
    //通过上面的计算，我们已经求得了每个长度为n的区间的最大和最小得分
	int minn = 1e8, maxx = 0;
    for(i = 1; i <= n; i++){	//遍历求出最大和最小的得分（每一个区间都是一条完整的链）
    	minn = min(minn, f1[i][i + n - 1]); 
    	maxx = max(maxx, f2[i][i + n - 1]); 
    } 
    printf("%d\n", minn);
    printf("%d", maxx);
    return 0;
}
 
P1063 能量项链
 
  洛谷：P1063 能量项链
 题目描述
   在Mars星球上，每个Mars人都随身佩带着一串能量项链。在项链上有N颗能量珠。能量珠是一颗有头标记与尾标记的珠子，这些标记对应着某个正整数。并且，对于相邻的两颗珠子，前一颗珠子的尾标记一定等于后一颗珠子的头标记。因为只有这样，通过吸盘（吸盘是Mars人吸收能量的一种器官）的作用，这两颗珠子才能聚合成一颗珠子，同时释放出可以被吸盘吸收的能量。如果前一颗能量珠的头标记为m，尾标记为r，后一颗能量珠的头标记为r，尾标记为n，则聚合后释放的能量为 m × r × n（Mars单位），新产生的珠子的头标记为m，尾标记为n。
   需要时，Mars人就用吸盘夹住相邻的两颗珠子，通过聚合得到能量，直到项链上只剩下一颗珠子为止。显然，不同的聚合顺序得到的总能量是不同的，请你设计一个聚合顺序，使一串项链释放出的总能量最大。
   例如：设 N = 4，4颗珠子的头标记与尾标记依次为(2,3) (3,5) (5,10) (10,2)。我们用记号⊕表示两颗珠子的聚合操作，(j⊕k)表示第j,k两颗珠子聚合后所释放的能量。则第4、1两颗珠子聚合后释放的能量为：(4⊕1) = 10 × 2 × 3 =60
 这一串项链可以得到最优值的一个聚合顺序所释放的总能量为：
   (((4⊕1)⊕2)⊕3）=10 × 2 × 3 + 10 × 3 × 5 + 10 × 5 × 10 = 710。
 输入格式
   第一行是一个正整数 N (4≤N≤100)，表示项链上珠子的个数。第二行是 N 个用空格隔开的正整数，所有的数均不超过1000。第 i 个数为第 i 颗珠子的头标记(1≤i≤N)，当i<Ni<N时，第i颗珠子的尾标记应该等于第i+1颗珠子的头标记。第N颗珠子的尾标记应该等于第1颗珠子的头标记。
   至于珠子的顺序，你可以这样确定：将项链放到桌面上，不要出现交叉，随意指定第一颗珠子，然后按顺时针方向确定其他珠子的顺序。
 输出格式
   一个正整数E (E ≤ 2.1 × 109)，为一个最优聚合顺序所释放的总能量。
 
分析：
 
  先分析下题意，存在一个环，上面有n个点，每个点可以看作是代表一个坐标(每个坐标的第二个数为下个坐标的第一个数)，当合并两个点(x, y)和(y, z)的时候，会释放总共x * y * z能量。我们已知有n个点，点之间两两用一条线段相连，总共有n条边，分别给边编号，如图所示：
 
   根据题意，(4⊕1) = 10 × 2 × 3 =60，恰好就是上图编号为4和编号为1的线段夹着的数和两边的数相乘得到的结果，这个环可以得到最优值的一个聚合顺序所释放的总能量为：
   (((4⊕1)⊕2)⊕3）=10 × 2 × 3 + 10 × 3 × 5 + 10 × 5 × 10 = 710。
   这跟前面那道题类似，也是一个环形dp的问题，因此我们可以先考虑线性dp的问题，接着再把环展开成长度为2 * n的链即可，样例中有四个点(2,3) (3,5) (5,10) (10,2)，在求聚合释放能量时，我们可以看做有五个数：2, 3, 5, 10, 2，最大能量用f[1][5]表示。这道题跟上面题目不同在于某个点可以被左区间，也可以被右区间计算，所以动态转移方程式为：f[l][r] = f[l][k] + f[k][r] + a[l] * a[k] * a[r])，k为分界点。
 
代码如下：
 
#include <bits/stdc++.h>
using namespace std;
int a[205], f[205][205], maxx;
int main(){
    int i, n, l, r, len, k;
    scanf("%d", &n);
    for(i = 1; i<= n; i++){
        scanf("%d", &a[i]);
       a[i + n] = a[i];	//把链的长度扩大一倍
    }
    for(len = 3; len <= n + 1; len++){	//从3 ~ n + 1 枚举区间长度
        for(l = 1; l <= 2 * n - len + 1; l++){	//枚举区间的左端点
            r = l + len - 1;	//枚举区间的右端点
            for(k = l + 1; k < r; k++){	//枚举区间中的分界点
                f[l][r] = max(f[l][r], f[l][k] + f[k][r] + a[l] * a[k] * a[r]);	//动态转移方程
            }
        }
    }
    for(i = 1; i <= n; i++){	//求出每段长度为n + 1的区间中的最大值
        maxx = max(maxx, f[i][i + n]);
    }
    printf("%d", maxx);
    return 0;
}
 
P1040 加分二叉树
 
  洛谷：P1040 加分二叉树
 题目描述
   设一个n个节点的二叉树tree的中序遍历为（1,2,3,…,n），其中数字1,2,3,…,n为节点编号。每个节点都有一个分数（均为正整数），记第i个节点的分数为di，tree及它的每个子树都有一个加分，任一棵子树subtree（也包含tree本身）的加分计算方法如下：     
   subtree的左子树的加分 × subtree的右子树的加分 ＋ subtree的根的分数 
   若某个子树为空，规定其加分为1。叶子的加分就是叶节点本身的分数，不考虑它的空子树。试求一棵符合中序遍历为（1,2,3,…,n）且加分最高的二叉树tree。
   要求输出： 
   （1）tree的最高加分 
   （2）tree的前序遍历
 输入格式
   第1行：一个整数n，为节点个数。 
   第2行：n个用空格隔开的整数，为每个节点的分数（0<分数<100）。
 输出格式
   第1行：一个整数，为最高加分（结果不会超过4,000,000,000）。     
   第2行：n个用空格隔开的整数，为该树的前序遍历。如果存在多种方案，则输出字典序最小的方案。
 数据范围
   n<30
 
分析：
 
代码如下：
 
#include <bits/stdc++.h>
using namespace std;
int a[35], f[35][35], g[35][35];
void dfs(int l, int r){
    if(l > r) return; 
    printf("%d ", g[l][r]);
    dfs(l, g[l][r] - 1);
    dfs(g[l][r] + 1, r);
    
}
int main(){
    int i, l, r, left, right, len, n, s, k;
    scanf("%d", &n);
    for(i = 1; i <= n; i++) scanf("%d", &a[i]);
    for(len = 1; len <= n; len++){	//枚举区间的长度
        for(l = 1; l <= n - len + 1; l++){	//枚举区间的左端点
            r = l + len - 1;	//枚举区间的右端点
            for(k = l; k <= r; k++){	//枚举区间的分界点
                if(k == l) left = 1;
                else left = f[l][k - 1];	//左子树的加分
                if(k == r) right = 1;
                else right = f[k + 1][r];	//右子树的加分
                s = left * right + a[k];	//左子树的加分 * 右子树的加分 + 根的分数
                if(l == r) s = a[k];	
                if(s > f[l][r]){	//更新区间的最大值
                    f[l][r] = s;	
                    g[l][r] = k;	//记录分界点，便于后续输出树的前序遍历
                }
            }
        }
    }
    printf("%d\n", f[1][n]);
    dfs(1, n);
    return 0;
}