前几日美赛建模前准备的BP神经网络模板，纯C++手写。
之后会找时间写一个使用方法，并配上测试样例，尽量加上过程图。

代码：

#include<bits/stdc++.h>
using namespace std;
#define maxn 150
#define p2(x) ((x)*(x))
const double len_v=0.5;///学习速率
int n,m,p,dep;///输入层n个神经元，输出层m个神经元，隐含层p个神经元,有dep层神经网络
struct level{
    double state[maxn];//激活情况
    int len;//该层网络的神经元个数
    void input(int x){
        len=x;
        for(int i=0;i<len;i++){
            scanf("%lf",&state[i]);
        }
    }
}in,out,hide[maxn];
struct netval{
    int s,t;//s个连接到t个
    double v[maxn][maxn];
}w[maxn];
double dif(level a,level b){
    double ret=0;
    for(int i=0;i<a.len;i++){
        ret+=p2(a.state[i]-b.state[i]);
    }
    return ret;
}
double sigmoid(double x){
    return 1/(1+exp(-x));
}
void init(){//初始化
    n=9;
    m=1;
    dep=1;
    p=6;
    for(int i=0;i<p;i++){
        hide[i].len=p;
    }
    for(int i=0;i<=dep;i++){//初始化边权网络w[]
        w[i].s=w[i].t=p;
        if(i==0)w[i].s=n;
        if(i==p)w[i].t=m;
        for(int j=0;j<w[i].s;j++){
            for(int k=0;k<w[i].s;k++){
                w[i].v[j][k]=(rand()%9+1)/10.0;
            }
        }
    }
}
level operator * (level a,netval b){//将a的状态通过b表转化
    level ret;
    memset(ret.state,0,sizeof(ret.state));
    ret.len=a.len;
    for(int i=0;i<ret.len;i++){
        for(int j=0;j<a.len;j++){
            ret.state[i]+=a.state[j]*b.v[j][i];
        }
    }
    return ret;
}
level operator * (netval a,level b){//根据a表将b的状态反推
    level ret;
    memset(ret.state,0,sizeof(ret.state));
    ret.len=b.len;
    for(int i=0;i<ret.len;i++){
        for(int j=0;j<b.len;j++){
            ret.state[i]+=b.state[j]*a.v[i][j];
        }
    }
    return ret;
}
netval operator * (level a,level b){//状态a和状态b生成转移二维表，受学习概率影响
    netval ret;
    ret.s=a.len;
    ret.t=b.len;
    for(int i=0;i<a.len;i++){
        for(int j=0;j<b.len;j++){
            ret.v[i][j]=a.state[i]*b.state[j];
        }
    }
    return ret;
}
netval operator + (netval a,netval b){
    for(int i=0;i<a.s;i++){
        for(int j=0;j<a.t;j++){
            a.v[i][j]+=b.v[i][j];
        }
    }
    return a;
}
level f(level x){//把x状态激活
    for(int i=0;i<x.len;i++){
        x.state[i]=sigmoid(x.state[i]);
    }
    return x;
}
level rf(level &x,level y){//用上一层反馈向量y，将当前状态x更新成残差状态
    for(int i=0;i<x.len;i++){
        x.state[i]= x.state[i]* (1-x.state[i])* y.state[i];
    }
}
level cal(level x){//把x作为输入层正向传播，返回输出层
    in=x;
    hide[0]=f(x*w[0]);
    for(int i=1;i<dep;i++){
        hide[i]=f(hide[i-1]*w[i]);
    }
    return out=f(hide[dep-1]*w[dep]);
}
void rebuild(level real){//将当前网络返向回馈改进边权
    //----------------反推回残差---------------------------------
    for(int i=0;i<out.len;i++){
        out.state[i]=-(out.state[i]-real.state[i])*out.state[i]*(1-out.state[i]);
    }
    rf(hide[dep-1],w[dep]*out);
    for(int i=dep-2;i>=0;i--){
        rf(hide[i],w[i+1]*hide[i+1]);
    }
    //----------------重新正推更新边权---------------------------
    w[0]=w[0]+in*hide[0];
    for(int i=1;i<dep;i++){
        w[i]=w[i]+hide[i-1]*hide[i];
    }
    w[dep]=w[dep]+hide[dep-1]*out;
}
void train(){

}
void my_test(){
    double s;
    while(scanf("%lf",&s)){
        printf("%lf\n",exp(s));
    }
}
int main(){
    init();
    my_test();
    test();
    return 0;
}
/* in --w[0]--> hide[0] --w[1]--> hide[1] -->...--w[dep-1]--> hide[dep-1] --w[dep]--> out */