dp洋洋散散的知识+code

/*在数轴上有0-N的位置
从0出发每次可以向右走
2
23
233步*/

// 1 总共的方案数

f[i]=f[i-]+f[i-]+f[i-];

        f[]=;
    for (int a=;a<=n;a++)
    {
        if (a>=) f[a]+=f[a-];
        if (a>=) f[a]+=f[a-];
        if (a>=) f[a]+=f[a-];
    }
    printf("%d\n",f[n]);

// 2 考虑恰好t次到达时
//dp 题 可以考虑 每多一个条件 数组就多一维；所以，开二维数组
//f[i][j] 表示 用 j 步走了i种方案

f[i][j]=f[i-][j-]+f[i-][j-]+f[i-][j-];

        f[][]=;
    for (int a=;a<=n;a++)
        for (int b=;b<=t;b++)
        {
            if (a>=) f[a][b]+=f[a-][b-];
            if (a>=) f[a][b]+=f[a-][b-];
            if (a>=) f[a][b]+=f[a-][b-];
        }
    printf("%d\n",f[n][t]);
        int ans=;
    for (int a=;a<=t;a++)
        ans+=f[n][a];
    printf("%d\n",ans);

//  3 考虑小于t次
//将
f[n][]+f[n][]+....f[n][t];

//考虑最多走r步233
//so 要再加一维，变成三维数组
//f[i][j][k] 表示走到 i点，公用j步，走233用了k步

f[i][j][k]=f[i-][j-][k]+ f[i-][j-][k]+ f[i-][j-][k-];
/*
(N,M)的方格图
从(0,0)开始
只能朝右或上走
问走到(N,M)的方案数*/ 

//将每个点的左边点和下边点相加

f[n][m]=f[n-][m]+f[n][m-];

//考虑有k个点（x，y）不能走
//定义布尔数组记录每个不能坐的点
每次设f[x][y]=，并加以判断；

//2.考虑每个坑只能掉一次：
if(不是坑)

F[i][j][k]=f[i-][j][k]+f[i][j-][k];

else if(是坑)

F[i][j][]=f[i-][j][]-f[i][j-][];

#include<iostream>
using namespace std;
int main()
{
    int n,i,j,a[][];
    cin>>n;
    for (i=; i<=n; i++)
        for (j=; j<=i; j++)
            cin>>a[i][j];                             //输入数字三角形的值
    for (i=n-; i>=; i--)
        for (j=; j<=i; j++)
        {
            if (a[i+][j]>=a[i+][j+])
            a[i][j]+=a[i+][j];     //路径选择
            else  a[i][j]+=a[i+][j+];
        }
    cout<<a[][]<<endl;
}

int fib(int a)
{
    if (!a) return ;
    if (a==) return ;
    if (g[a]) return f[a];
    g[a]=true;
    f[a]=fib(a-)+fib(a-);
    return f[a];
}
 数字三角形问题，使得答案对p取模最大？

F[i][j][k] 表示走到第i行第j列 使得答案模p是否可行

F[i][j][k]=f[i+][j][k-v[i][j]]
Or
F[i+][j+][k-v[i][j]]
**********代码：

    for (int a=;a<=n;a++)
        f[n][a][v[n][a]%p]=true;
    for (int a=n-;a>=;a--)
        for (int b=;b<=a;b++)
            for (int c=;c<p;c++)
                f[a][b][c]=
                    f[a+][b][(c-v[a][b]+p)%p] ||
                    f[a+][b+][(c-v[a][b]+p)%p];
    int ans;
    for (int a=p-;a>=;a--)
        if (f[][][a])
        {
            ans=a;
            break;
        }

//***********区间DP******** 

/*合并石子

每次选择相邻两堆

代价为两堆石子和

问最小总代价

(第一层for循环一定要正着写)

因为后一层循环需要前一层循环的数据 */

F[l][r]=min(f[l][k]+f[k+][r]+sum[l][r])

/*矩阵乘法
自定义顺序
使得运算次数最少*/

//F[i][j] 表示搞定[I,j]的最小代价
F[i][j] = min(f[i][k]+f[k][j+]+cost(I,k,j))